Publishing Governor

The Publishing Governor provides methods for controlling the public visibility of tournament information through publish state management. These methods work in conjunction with Time Items to track what's published and when.

import { publishingGovernor } from 'tods-competition-factory';

tip

See Publishing Concepts for comprehensive coverage of publishing workflows, rationale, and best practices.

getPublishState

Returns publishing details for tournament, event(s), and/or draws, enabling queries about current publish state before making changes. See examples: Queryable Publish State, Queryable Publish State.

Return All Publish State

const { publishState } = engine.getPublishState();

// Tournament-level state
const participantsPublished = publishState.tournament.participants.published;
const orderOfPlayPublished = publishState.tournament.orderOfPlay.published;

// Event-level state (accessed by eventId)
const eventState = publishState['eventId'].status;
const {
  published, // boolean - is event published?
  publishedDrawIds, // array of published draw IDs
  drawDetails, // granular stage/structure details
} = eventState;

Query Specific Event

const { publishState } = engine.getPublishState({ eventId });
const eventPublished = publishState.status.published;
const publishedDraws = publishState.status.publishedDrawIds;

Query Specific Draw

const { publishState } = engine.getPublishState({ drawId });
const drawPublished = publishState.status.published;

// When only specific stages or structures are published
const drawPublishDetail = publishState.status.drawDetail;
// Example structure: { stages: ['MAIN'], structures: { [structureId]: { roundLimit: 2 } } }

Embargo Status

When embargoes are present, the return includes an embargoes array summarizing all active and expired embargoes across the tournament:

const { publishState } = engine.getPublishState();

// publishState.embargoes is present when any embargoes exist
publishState.embargoes?.forEach(({ type, id, embargo, embargoActive }) => {
  console.log(`${type} ${id ?? ''}: ${embargo} (active: ${embargoActive})`);
});

Each entry in the embargoes array:

Field	Type	Description
`type`	string	`'draw'`, `'stage'`, `'structure'`, `'scheduledRound'`, `'orderOfPlay'`, or `'participants'`
`id`	string?	Identifier for the element. Absent for tournament-level types (`orderOfPlay`, `participants`).
`embargo`	string	ISO 8601 timestamp
`embargoActive`	boolean	`true` if the embargo is still in the future

note

getPublishState intentionally ignores embargo timestamps when determining publish status. This is for admin/reporting use — embargoed elements appear as "published" so admin UIs can display their configuration correctly. See Embargo: Admin vs Public Behavior for details.

Use Cases:

Verify current state before publishing
Display publish status in admin UI
Determine if re-publishing is needed
Query embargo status and expiry times
Build admin dashboards showing upcoming embargo releases

See: Embargo for comprehensive embargo documentation.

bulkUpdatePublishedEventIds

Updates which events are marked as published across multiple events simultaneously. Used for bulk publish state management.

const result = engine.bulkUpdatePublishedEventIds({
  tournamentRecord, // required
  publishedEventIds, // array of eventIds to mark as published
});

Returns:

{
  success: boolean;
  updatedCount?: number;
}

Purpose: Efficiently update publish status for multiple events at once, typically during tournament-wide publish operations.

getAllEventData

Returns comprehensive data for all events in a tournament, formatted for public display.

const { eventsData, tournamentInfo, venuesData } = engine.getAllEventData({
  tournamentRecord, // required
  policyDefinitions, // optional - privacy policies to apply
});

// eventsData structure
eventsData.forEach((event) => {
  console.log(event.eventInfo); // Event details
  console.log(event.scheduleTiming); // Timing information
  event.drawsData.forEach((draw) => {
    console.log(draw.drawInfo);
    console.log(draw.matchUps); // Categorized matchUps
  });
});

Returns:

{
  eventsData: Array<{
    eventInfo: EventInfo;
    scheduleTiming: any;
    drawsData: Array<{
      drawInfo: DrawInfo;
      matchUps: {
        abandonedMatchUps: MatchUp[];
        completedMatchUps: MatchUp[];
        upcomingMatchUps: MatchUp[];
        pendingMatchUps: MatchUp[];
      };
    }>;
  }>;
  tournamentInfo: TournamentInfo;
  venuesData: Venue[];
}

Purpose: Get complete tournament data formatted for public websites, scoreboards, or apps.

getCourtInfo

Returns detailed information about a specific court, including availability and bookings.

const { courtInfo } = engine.getCourtInfo({
  courtId, // required
  tournamentRecord, // required
});

console.log(courtInfo.courtName);
console.log(courtInfo.dateAvailability);

Returns:

{
  courtInfo: {
    courtId: string;
    courtName: string;
    venueId: string;
    dateAvailability?: DateAvailability[];
    // ... other court properties
  };
}

Purpose: Get complete court details for scheduling interfaces or public venue information.

getDrawData

Returns comprehensive draw data including structures, matchUps, and participant assignments, formatted for display.

const { drawInfo, structures } = engine.getDrawData({
  drawDefinition, // required
  tournamentRecord, // required
  event, // required
  usePublishState, // optional boolean - respect publish state
  includePositionAssignments, // optional boolean - include draw positions
  policyDefinitions, // optional - privacy policies
  inContext, // optional boolean - add context to matchUps
});

Returns:

{
  drawInfo: {
    drawId: string;
    drawName: string;
    drawType: string;
    // ... other draw properties
  }
  structures: Array<{
    structureId: string;
    structureName: string;
    matchUps: MatchUp[];
    roundMatchUps: { [roundNumber: string]: MatchUp[] };
    positionAssignments?: PositionAssignment[];
    // ... other structure data
  }>;
  success: boolean;
}

Purpose: Primary method for getting formatted draw data for display in brackets, schedules, or results pages.

When to Use:

Building bracket displays
Generating draw sheets
Exporting draw data
Public-facing draw views

Notes:

Respects publish state when usePublishState: true
Applies privacy policies to participant data
Returns only published structures/rounds when appropriate
Enforces embargo timestamps — embargoed structures are filtered out until the embargo passes
Used internally by getEventData

getEventData

Returns comprehensive event data including all draws, participants, and matchUps, formatted for public display.

const { eventData, participants } = engine.getEventData({
  eventId, // required (or event object)
  tournamentRecord, // required
  usePublishState, // optional boolean - respect publish state
  hydrateParticipants, // optional boolean - add full participant details
  includePositionAssignments, // optional boolean - include draw positions
  participantsProfile, // optional - control participant data included
  policyDefinitions, // optional - privacy policies
  contextProfile, // optional - control matchUp context
  allParticipantResults, // optional boolean - include all results
});

Returns:

{
  eventData: {
    eventInfo: EventInfo;
    drawsData: Array<{
      drawInfo: DrawInfo;
      structures: Structure[];
    }>;
    tournamentInfo?: TournamentInfo;
    venuesData?: Venue[];
  };
  participants?: HydratedParticipant[];
  success: boolean;
}

Purpose: Primary method for generating complete event data payloads for websites, apps, and scoreboards.

Use Cases:

Publishing event data to public APIs
Generating event pages
Creating scoreboard displays
Exporting event data

Publish State Integration:

When usePublishState: true, only returns published draws/structures
Respects round limits and stage restrictions
Enforces embargo timestamps at draw, stage, and structure levels — embargoed content is hidden until the embargo passes
Applies privacy policies

Notes:

Most commonly used method for public data generation
Automatically called by publishEvent to generate payload
Respects all display and privacy extensions
Returns hydrated participants with complete details when requested

getEventPublishStatus

Returns detailed publish status for a specific event.

const { eventPublishStatus } = engine.getEventPublishStatus({
  eventId, // required
  tournamentRecord, // required
  event, // optional - event object if already loaded
});

console.log(eventPublishStatus.published); // boolean
console.log(eventPublishStatus.publishedDrawIds); // array of draw IDs
console.log(eventPublishStatus.drawDetails); // granular details

Returns:

{
  eventPublishStatus: {
    published: boolean;
    publishedDrawIds?: string[];
    drawDetails?: {
      [drawId: string]: {
        stages?: string[];
        structures?: {
          [structureId: string]: {
            roundLimit?: number;
            published?: boolean;
          };
        };
      };
    };
  };
}

Purpose: Query precise publish state for an event to determine what's visible.

getRoundVisibilityState

Computes per-round visibility state (hidden / embargoed) for a draw structure. Used by clients to determine which rounds should be visually hidden (beyond roundLimit) or marked as embargoed when rendering a draw.

const { publishState } = engine.getPublishState({ event });
const structureDetail = publishState?.status?.drawDetails?.[drawId]?.structureDetails?.[structureId];

const roundVisibility = publishingGovernor.getRoundVisibilityState(
  structureDetail,
  matchUps, // array of matchUp objects — only roundNumber is read
);

// roundVisibility is Record<number, { hidden?: boolean; embargoed?: boolean }> | undefined
if (roundVisibility) {
  for (const [roundNumber, state] of Object.entries(roundVisibility)) {
    if (state.hidden) console.log(`Round ${roundNumber} is beyond roundLimit`);
    if (state.embargoed) console.log(`Round ${roundNumber} has active schedule embargo`);
  }
}

Parameters:

Parameter	Type	Description
`structureDetail`	`PublishingDetail`	Structure-level publishing detail from `getPublishState()`. Contains optional `roundLimit` and `scheduledRounds`.
`matchUps`	`{ roundNumber?: number }[]`	Array of matchUp objects for the structure. Only `roundNumber` is read to determine the maximum round.

Returns:

Record<number, RoundVisibility> | undefined;

interface RoundVisibility {
  hidden?: boolean; // true when roundNumber > roundLimit
  embargoed?: boolean; // true when scheduledRound has active embargo
}

Returns undefined when no rounds have visibility restrictions (no roundLimit set and no active embargoes).

note

A round can be both hidden and embargoed simultaneously — for example, when a round is beyond the roundLimit and also has a schedule embargo.

Purpose:

Render draw structures with correct round visibility in admin/public views
Determine which rounds to grey out, hide, or mark with embargo indicators
Drive UI indicators for schedule embargo status per round

See: Publishing Events for roundLimit usage, Embargo for embargo concepts.

getTournamentPublishStatus

Returns publish status for tournament-level items (participants, order of play).

const { publishStatus } = engine.getTournamentPublishStatus({
  tournamentRecord, // required
});

console.log(publishStatus.participants.published); // boolean
console.log(publishStatus.participants.publishedAt); // ISO timestamp
console.log(publishStatus.orderOfPlay.published); // boolean

Returns:

{
  publishStatus: {
    participants: {
      published: boolean;
      publishedAt?: string;
    };
    orderOfPlay: {
      published: boolean;
      publishedAt?: string;
    };
  };
}

Purpose: Check if tournament-wide items like participants and order of play are published.

isEmbargoed

Returns true if a publishing detail has an active embargo — i.e., the embargo field is a valid ISO date string in the future.

import { publishingGovernor } from 'tods-competition-factory';

const { publishState } = engine.getPublishState({ event });
const drawDetail = publishState?.status?.drawDetails?.[drawId]?.publishingDetail;

if (publishingGovernor.isEmbargoed(drawDetail)) {
  console.log('Draw is under embargo until', drawDetail.embargo);
}

// Also works with scheduled round details
const roundDetail =
  publishState?.status?.drawDetails?.[drawId]?.structureDetails?.[structureId]?.scheduledRounds?.[roundNumber];

if (publishingGovernor.isEmbargoed(roundDetail)) {
  console.log('Round schedule is embargoed');
}

Parameters:

Parameter	Type	Description
`detail`	`PublishingDetail \| undefined`	Any publishing detail object that may contain an `embargo` field.

Returns: boolean — true when detail.embargo is a valid ISO date string in the future.

note

Returns false for undefined, missing embargo field, or expired/invalid embargo dates. Validates ISO format before comparing.

isVisiblyPublished

Returns true if a publishing detail is both published and not currently embargoed. Combines the published flag check with the embargo expiry check.

import { publishingGovernor } from 'tods-competition-factory';

const drawDetail = publishState?.status?.drawDetails?.[drawId]?.publishingDetail;

if (publishingGovernor.isVisiblyPublished(drawDetail)) {
  // Draw is published and any embargo has expired — show to public
}

Parameters:

Parameter	Type	Description
`detail`	`PublishingDetail \| undefined`	Any publishing detail object with `published` and optional `embargo` fields.

Returns: boolean — true when detail.published === true and isEmbargoed(detail) is false.

Purpose: Determine if content should be visible to end users, respecting both the publish flag and any active embargo.

getVenueData

Returns formatted venue data for public display.

const { venueData } = engine.getVenueData({
  venueId, // required
  tournamentRecord, // required
});

console.log(venueData.venueName);
console.log(venueData.courts); // Array of court objects
console.log(venueData.venueAddress);

Returns:

{
  venueData: {
    venueId: string;
    venueName: string;
    venueAbbreviation?: string;
    courts: Court[];
    venueAddress?: Address;
    // ... other venue properties
  };
}

Purpose: Get complete venue information for public display, maps, or venue guides.

publishEvent

Publishes event draws and structures with fine-grained control over visibility. Generates optimized eventData payload and triggers PUBLISH_EVENT subscription notifications. See examples in Publishing All Draws.

Key Features:

Publishes entire events or specific draws (flights)
Stage-level control (MAIN, QUALIFYING, CONSOLATION)
Structure and round-level granularity
Embargo support for scheduled publication
Privacy policy application
Subscription notification with prepared payload

const { eventData } = engine.publishEvent({
  eventId, // required — event to publish (resolved by engine)

  // Draw selection (choose one approach)
  drawIdsToAdd, // optional array — publish specific draws
  drawIdsToRemove, // optional array — unpublish specific draws
  drawIds, // optional array — publish only these draws (alternative to add/remove)
  drawDetails, // optional object — granular per-draw control (see below)

  // Data preparation
  includePositionAssignments, // optional boolean — include positionAssignments in eventData
  eventDataParams, // optional object — params for getEventData (not persisted in publish state)
  policyDefinitions, // optional — privacy policies to apply
  returnEventData, // optional boolean — return eventData even without PUBLISH_EVENT subscription

  // State management
  removePriorValues, // optional boolean — clear previous timeItems
  status, // optional string — publish status key, defaults to 'PUBLIC'
});

Publishing Patterns

Publish All Draws in Event

engine.publishEvent({ eventId });

Publish Specific Draws (Flights)

// Shorthand
engine.publishEvent({
  eventId,
  drawIdsToAdd: ['drawId1', 'drawId2'],
});

// Remove draws from publication
engine.publishEvent({
  eventId,
  drawIdsToRemove: ['drawId3'],
});

Publish by Stage

import { stageConstants } from 'tods-competition-factory';

engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      stagesToAdd: [stageConstants.QUALIFYING],
      publishingDetail: { published: true },
    },
  },
});

Round-by-Round Publishing

// Publish only first round of a structure
engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      structureDetails: {
        [structureId]: {
          roundLimit: 1,
          published: true,
        },
      },
    },
  },
});

// Expand to include more rounds
engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      structureDetails: {
        [structureId]: {
          roundLimit: 3, // Now shows rounds 1-3
          published: true,
        },
      },
    },
  },
});

Scheduled Rounds (Per-Round Schedule Control)

Use scheduledRounds within structureDetails for fine-grained control over which rounds' matchUps appear in the schedule. This is separate from roundLimit bracket filtering (which only applies to AD_HOC draws).

// Embargo round 2 schedule, explicitly hide round 3; round 1 unlisted → passes through
engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      structureDetails: {
        [structureId]: {
          published: true,
          roundLimit: 3, // bracket ceiling (AD_HOC only)
          scheduledRounds: {
            2: { published: true, embargo: '2024-06-16T08:00:00Z' },
            3: { published: false },
            // round 1 not listed → passes through normally
          },
        },
      },
    },
  },
});

Behavior:

roundLimit always acts as a ceiling for the schedule (all draw types)
scheduledRounds is an override map — only rounds with an explicit entry are affected; unlisted rounds pass through normally
{ published: false } explicitly hides the round (matchUps removed from results)
{ published: true, embargo: FUTURE } returns the matchUp without schedule data (schedule stripped) until the embargo passes
When scheduledRounds is absent, all rounds up to roundLimit appear in the schedule

Note: roundLimit only filters the bracket (draw data) for AD_HOC draw types. For elimination draws, the bracket always shows all rounds.

Publishing with Embargo

Embargo allows content to be marked as published but hidden from public queries until a specified time. The embargo field accepts an ISO 8601 timestamp string. Embargoes can be applied at draw, stage, and structure levels.

const embargoTime = new Date('2024-06-15T10:00:00Z').toISOString();

// Draw-level embargo — entire draw hidden until embargo passes
engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      publishingDetail: {
        published: true,
        embargo: embargoTime,
      },
    },
  },
});

// Stage-level embargo — qualifying visible, main embargoed
engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      publishingDetail: { published: true },
      stageDetails: {
        QUALIFYING: { published: true },
        MAIN: { published: true, embargo: embargoTime },
      },
    },
  },
});

// Structure-level embargo — specific structure hidden
engine.publishEvent({
  eventId,
  drawDetails: {
    [drawId]: {
      publishingDetail: { published: true },
      structureDetails: {
        [structureId]: { published: true, embargo: embargoTime },
      },
    },
  },
});

Embargoed content is automatically visible once the system clock passes the embargo timestamp — no second mutation needed.

Affected queries: getEventData, getDrawData, competitionScheduleMatchUps (when usePublishState: true).

Admin visibility: getPublishState ignores embargoes and reports full publish configuration including embargo metadata.

See: Embargo for comprehensive embargo documentation including workflows and admin vs public behavior.

Publishing with Privacy Policies

import { policyConstants } from 'tods-competition-factory';

const privacyPolicy = {
  participant: {
    contacts: false,
    addresses: false,
    individualParticipants: {
      contacts: false,
      addresses: false,
    },
  },
};

const { eventData } = engine.publishEvent({
  eventId,
  policyDefinitions: {
    [policyConstants.POLICY_TYPE_PARTICIPANT]: privacyPolicy,
  },
});

Customizing Event Data Payload

important

Event data parameters are not persisted in publish state. Client applications must pass their own parameters when querying with usePublishState: true.

// Server-side publishing
const { eventData } = engine.publishEvent({
  eventId,
  eventDataParams: {
    allParticipantResults: true,
    participantsProfile: {
      withISO2: true,
      withIOC: true,
    },
  },
});

// Client must pass same params when querying
const { eventData: clientData } = engine.getEventData({
  eventId,
  usePublishState: true,
  allParticipantResults: true,
  participantsProfile: { withISO2: true, withIOC: true },
});

See: Publishing Concepts for details on eventData structure.

publishEventSeeding

Publishes event seeding information separately from draw structures, enabling flexible control over when seeding becomes publicly visible. See examples: Publishing Seeding, Publishing Seeding, Coordinated Event and Seeding Release.

Why Separate Seeding Publication:

Prevent participants from knowing seeded positions before draws finalized
Announce seeded players separately from draw structure
Update seeding without re-publishing entire draw
Different scales for different stages

engine.publishEventSeeding({
  eventId, // required

  // Scale selection
  seedingScaleNames, // optional - array of scale names
  stageSeedingScaleNames, // optional - { MAIN: 'scale1', QUALIFYING: 'scale2' }

  // Draw selection
  drawIds, // optional - publish specific draws only

  // State management
  removePriorValues, // optional boolean - clear previous timeItems
});

publishEventSeeding Examples

Publish All Seeding

engine.publishEventSeeding({ eventId });

Publish Specific Scales

engine.publishEventSeeding({
  eventId,
  seedingScaleNames: ['U18', 'WTN'],
});

Different Scales per Stage

engine.publishEventSeeding({
  eventId,
  stageSeedingScaleNames: {
    MAIN: 'U18',
    QUALIFYING: 'U18Q',
  },
});

Publish Specific Flights

engine.publishEventSeeding({
  eventId,
  drawIds: ['flight1', 'flight2'],
});

publishOrderOfPlay

Publishes scheduled matchUps (Order of Play), controlling visibility of which matches are scheduled for which courts and times. See examples in Publishing Scheduled MatchUps.

Why Order of Play Publishing:

Prepare schedules internally before announcing
Make scheduling changes before public release
Coordinate releases with media partners
Publish each day's schedule separately

engine.publishOrderOfPlay({
  scheduledDates, // optional - array of dates to publish
  eventIds, // optional - array of events to publish
  embargo, // optional - ISO 8601 timestamp; schedule hidden until this time
  removePriorValues, // optional boolean - clear previous timeItems
});

publishOrderOfPlay Examples

Publish All Scheduled MatchUps

engine.publishOrderOfPlay();

Publish Specific Dates

engine.publishOrderOfPlay({
  scheduledDates: ['2024-06-15', '2024-06-16'],
});

Publish Specific Events

engine.publishOrderOfPlay({
  eventIds: ['singles-main', 'doubles-main'],
});

Daily Publication

// Each morning, publish that day's schedule
const today = new Date().toISOString().split('T')[0];

engine.publishOrderOfPlay({
  scheduledDates: [today],
  removePriorValues: false, // Keep previous days published
});

publishOrderOfPlay with Embargo

// Schedule becomes visible after 6pm the evening before
engine.publishOrderOfPlay({
  scheduledDates: ['2024-06-15'],
  embargo: '2024-06-14T18:00:00Z',
});

When embargoed, competitionScheduleMatchUps with usePublishState: true returns empty dateMatchUps until the embargo passes.

See: Embargo for comprehensive embargo documentation.

Replace All Previous Publications

engine.publishOrderOfPlay({
  scheduledDates: ['2024-06-15'],
  eventIds: ['singles-main'],
  removePriorValues: true, // Clear all previous
});

Query Published Schedules:

const { dateMatchUps } = engine.competitionScheduleMatchUps({
  usePublishState: true, // Only returns published matchUps
});

See: Query Governor - competitionScheduleMatchUps

publishParticipants

Publishes the tournament participant list, controlling when participant information becomes publicly visible. See examples: Why Participant Publishing?, Why Participant Publishing?.

Why Participant Publishing:

Accept entries internally before announcing participant list
Control when participant information becomes public
Coordinate announcements with promotional campaigns
Staged announcements (wildcards separate from direct acceptances)

engine.publishParticipants({
  embargo, // optional - ISO 8601 timestamp; participant list hidden until this time
  removePriorValues, // optional boolean - clear previous timeItems
});

publishParticipants Examples

Publish Participants

engine.publishParticipants();

publishParticipants with Embargo

// Participant list visible after 9am on June 10th
engine.publishParticipants({
  embargo: '2024-06-10T09:00:00Z',
});

See: Embargo for comprehensive embargo documentation.

Replace Previous Publication

engine.publishParticipants({
  removePriorValues: true,
});

setEventDisplay

Sets display configuration for event data, controlling which attributes are visible for specific draws and dates. See examples: Display Settings.

engine.setEventDisplay({
  eventId, // required
  displaySettings, // required - display configuration object
  removePriorValues, // optional boolean - clear previous settings
});

Purpose: Fine-grained control over data visibility in published events, for privacy compliance and progressive disclosure.

unPublishEvent

Removes event from public visibility. Triggers UNPUBLISH_EVENT subscription notification. See examples: Unpublishing Events.

engine.unPublishEvent({
  eventId, // required
  removePriorValues, // optional boolean, defaults to true
});

unPublishEvent Examples

// Unpublish event (removes timeItems)
engine.unPublishEvent({ eventId });

// Unpublish without removing timeItems
engine.unPublishEvent({
  eventId,
  removePriorValues: false,
});

Use Cases:

Draw corrections needed before re-publishing
Event cancelled or postponed
Major scheduling changes requiring republication
Remove from public site while maintaining internal data

unPublishEventSeeding

Removes seeding information from public visibility. See examples: Unpublishing Seeding.

engine.unPublishEventSeeding({
  eventId, // required
  stages, // optional - array of stages to unpublish
  removePriorValues, // optional boolean, defaults to true
});

unPublishEventSeeding Examples

Unpublish All Seeding

engine.unPublishEventSeeding({ eventId });

Unpublish Specific Stages

engine.unPublishEventSeeding({
  eventId,
  stages: [stageConstants.MAIN, stageConstants.QUALIFYING],
});

Use Cases:

Seeding corrections needed
Change seeding methodology
Remove seeding before draw changes

unPublishOrderOfPlay

Removes Order of Play from public visibility. See examples: Unpublishing Order of Play.

engine.unPublishOrderOfPlay({
  removePriorValues, // optional boolean, defaults to true
});

unPublishOrderOfPlay Examples

// Unpublish all schedules
engine.unPublishOrderOfPlay();

// Keep timeItems
engine.unPublishOrderOfPlay({
  removePriorValues: false,
});

Use Cases:

Major scheduling changes
Venue changes affecting schedule
Weather delays requiring reschedule
Remove from public pending updates

unPublishParticipants

Removes participant list from public visibility. See examples: Unpublishing Participants.

engine.unPublishParticipants({
  removePriorValues, // optional boolean, defaults to true
});

unPublishParticipants Examples

// Unpublish participants
engine.unPublishParticipants();

Use Cases:

Entry deadline extended
Major withdrawals requiring list update
Corrections to participant information

Integration Patterns

Subscription-Based Publishing

import { topicConstants } from 'tods-competition-factory';

const subscriptions = {
  [topicConstants.PUBLISH_EVENT]: async (payload) => {
    const { eventData, eventId } = payload;
    // Update public website
    await fetch('https://public-site.com/api/events', {
      method: 'POST',
      body: JSON.stringify(eventData),
    });
  },

  [topicConstants.PUBLISH_ORDER_OF_PLAY]: async (payload) => {
    const { dateMatchUps } = payload;
    // Update schedule displays
    await updateScheduleDisplay(dateMatchUps);
  },

  [topicConstants.UNPUBLISH_EVENT]: async (payload) => {
    const { eventId } = payload;
    // Remove from public site
    await removeFromPublicSite(eventId);
  },
};

engine.devContext({ subscriptions });

Database Synchronization

[topicConstants.PUBLISH_ORDER_OF_PLAY]: async (payload) => {
  const { dateMatchUps } = payload;
  await database.updatePublishedSchedule(dateMatchUps);
  cache.invalidate('schedules');
}

Cache Management

[topicConstants.UNPUBLISH_EVENT]: (payload) => {
  const { eventId } = payload;
  cache.invalidate(`event:${eventId}`);
  cache.invalidate('published-events-list');
}

Publishing Concepts - Comprehensive workflows and best practices
Embargo - Time-based visibility control for published content
Time Items - How publish state is stored
Subscriptions - Notification system
Query Governor - Methods using publish state with embargo enforcement
Policies - Privacy and display policies

getPublishState​

Return All Publish State​

Query Specific Event​

Query Specific Draw​

Embargo Status​

bulkUpdatePublishedEventIds​

getAllEventData​

getCourtInfo​

getDrawData​

getEventData​

getEventPublishStatus​

getRoundVisibilityState​

getTournamentPublishStatus​

isEmbargoed​

isVisiblyPublished​

getVenueData​

publishEvent​

Publishing Patterns​

Publish All Draws in Event​

Publish Specific Draws (Flights)​

Publish by Stage​

Round-by-Round Publishing​

Scheduled Rounds (Per-Round Schedule Control)​

Publishing with Embargo​

Publishing with Privacy Policies​

Customizing Event Data Payload​

publishEventSeeding​

publishEventSeeding Examples​

Publish All Seeding​

Publish Specific Scales​

Different Scales per Stage​

Publish Specific Flights​

publishOrderOfPlay​

publishOrderOfPlay Examples​

Publish All Scheduled MatchUps​

Publish Specific Dates​

Publish Specific Events​

Daily Publication​

publishOrderOfPlay with Embargo​

Replace All Previous Publications​

publishParticipants​

publishParticipants Examples​

Publish Participants​

publishParticipants with Embargo​

Replace Previous Publication​

setEventDisplay​

unPublishEvent​

unPublishEvent Examples​

unPublishEventSeeding​

unPublishEventSeeding Examples​

Unpublish All Seeding​

Unpublish Specific Stages​

unPublishOrderOfPlay​

unPublishOrderOfPlay Examples​

unPublishParticipants​

unPublishParticipants Examples​

Integration Patterns​

Subscription-Based Publishing​

Database Synchronization​

Cache Management​

Related Documentation​

getPublishState

Return All Publish State

Query Specific Event

Query Specific Draw

Embargo Status

bulkUpdatePublishedEventIds

getAllEventData

getCourtInfo

getDrawData

getEventData

getEventPublishStatus

getRoundVisibilityState

getTournamentPublishStatus

isEmbargoed

isVisiblyPublished

getVenueData

publishEvent

Publishing Patterns

Publish All Draws in Event

Publish Specific Draws (Flights)

Publish by Stage

Round-by-Round Publishing

Scheduled Rounds (Per-Round Schedule Control)

Publishing with Embargo

Publishing with Privacy Policies

Customizing Event Data Payload

publishEventSeeding

publishEventSeeding Examples

Publish All Seeding

Publish Specific Scales

Different Scales per Stage

Publish Specific Flights

publishOrderOfPlay

publishOrderOfPlay Examples

Publish All Scheduled MatchUps

Publish Specific Dates

Publish Specific Events

Daily Publication

publishOrderOfPlay with Embargo

Replace All Previous Publications

publishParticipants

publishParticipants Examples

Publish Participants

publishParticipants with Embargo

Replace Previous Publication

setEventDisplay

unPublishEvent

unPublishEvent Examples

unPublishEventSeeding

unPublishEventSeeding Examples

Unpublish All Seeding

Unpublish Specific Stages

unPublishOrderOfPlay

unPublishOrderOfPlay Examples

unPublishParticipants

unPublishParticipants Examples

Integration Patterns

Subscription-Based Publishing

Database Synchronization

Cache Management

Related Documentation