velocious 1.0.502 → 1.0.503

package/build/src/sync/sync-publisher.js

@@ -0,0 +1,305 @@
+// @ts-check
+import Configuration from "../configuration.js";
+import Logger from "../logger.js";
+import restArgsError from "../utils/rest-args-error.js";
+import { deliverDeclaredBroadcasts, upsertSyncRow } from "./sync-change-fanout.js";
+import { isPublishingSuppressed } from "./sync-publish-suppression.js";
+/** @type {{create: "afterCreate", update: "afterUpdate", destroy: "afterDestroy"}} */
+const PUBLISHED_CALLBACK_NAMES = { create: "afterCreate", destroy: "afterDestroy", update: "afterUpdate" };
+/**
+ * Operations published by default for models declaring `static sync` publish
+ * without an `operations` key: server-side creates and updates publish
+ * automatically. Destroys are not published by default because a server
+ * destroy is often cleanup rather than a synced delete; opt in with an
+ * operations list.
+ * @type {Array<"create" | "update" | "destroy">} */
+const DEFAULT_PUBLISHED_OPERATIONS = ["create", "update"];
+/** @type {WeakMap<Configuration, SyncPublisher>} */
+const startedPublishersByConfiguration = new WeakMap();
+/**
+ * Declarative server-side sync publisher — the server mirror of the client's
+ * track-by-default mutation tracking.
+ *
+ * Server models declare what to publish through `static sync`'s `publish`
+ * key, and Velocious writes every committed server-side change to the sync
+ * change feed (model-backed Sync-row upsert with server re-sequencing) and
+ * fans out the declared broadcasts, so devices receive server-origin changes
+ * without app code calling manual upsert/broadcast helpers:
+ *
+ *     static sync = {
+ *       publish: {
+ *         serialize: (event) => ({id: event.id(), eventPin: event.eventPin()}),
+ *         eventId: (event) => event.id(),
+ *         broadcasts: [{channel: "ticket-scans", broadcastParams: ..., body: ...}]
+ *       }
+ *     }
+ *
+ * Replayed device mutations never double-publish: the framework's routed
+ * replay apply marks its written records through `markServerApply(record)`
+ * (see sync-publish-suppression.js), and app code applying already-synced
+ * data can use `markServerApply`/`withoutPublishing` the same way.
+ */
+export default class SyncPublisher {
+    /**
+     * Builds the sync publisher by deriving published resources from the
+     * configuration's registered models: every model declaring `static sync`
+     * with a `publish` declaration becomes a published resource
+     * (`publish: false` opts out). The sync/change model is the registered
+     * "Sync" model and broadcasts default to the configuration's channel
+     * broadcast.
+     * @param {import("./sync-publisher-types.js").SyncPublisherOptions} [options] - Optional overrides.
+     */
+    constructor(options = {}) {
+        const { actorForeignKeyColumn = "authentication_token_id", broadcaster, configuration = Configuration.current(), onError, syncModel, ...restOptions } = options;
+        restArgsError(restOptions);
+        const modelClasses = configuration.getModelClasses();
+        /** @type {Record<string, import("./sync-publisher-types.js").SyncPublisherResourceConfig>} */
+        const resources = {};
+        for (const modelClass of Object.values(modelClasses)) {
+            const publish = publishDeclarationFor(modelClass);
+            if (!publish)
+                continue;
+            const resourceConfig = resourceConfigFromPublishDeclaration({ modelClass, publish });
+            resources[resourceConfig.resourceType] = resourceConfig;
+        }
+        if (Object.keys(resources).length === 0) {
+            throw new Error("SyncPublisher found no registered models declaring static sync publish - declare `static sync = {publish: {serialize}}` on the models whose server-side changes should publish to the sync feed");
+        }
+        const resolvedSyncModel = syncModel || modelClasses.Sync;
+        if (!resolvedSyncModel) {
+            throw new Error("SyncPublisher requires a registered \"Sync\" model for published sync change rows (or pass options.syncModel)");
+        }
+        /** @type {{actorForeignKeyColumn: string, broadcaster: import("./sync-publisher-types.js").SyncPublisherOptions["broadcaster"], configuration: Configuration, onError: import("./sync-publisher-types.js").SyncPublisherOptions["onError"], resources: Record<string, import("./sync-publisher-types.js").SyncPublisherResourceConfig>, syncModel: ?}} */
+        this.config = { actorForeignKeyColumn, broadcaster, configuration, onError, resources, syncModel: resolvedSyncModel };
+        /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: "afterCreate" | "afterUpdate" | "afterDestroy", modelClass: ?}>} */
+        this._publishedCallbacks = [];
+        /** @type {Logger | null} */
+        this._logger = null;
+        this._started = false;
+    }
+    /**
+     * Builds a sync publisher derived from the given configuration. Alias for
+     * `new SyncPublisher({configuration, ...options})`.
+     * @param {Configuration} [configuration] - Configuration owning the registered models. Defaults to the current configuration.
+     * @param {Omit<import("./sync-publisher-types.js").SyncPublisherOptions, "configuration">} [options] - Optional overrides.
+     * @returns {SyncPublisher} Sync publisher derived from the configuration.
+     */
+    static fromConfiguration(configuration = Configuration.current(), options = {}) {
+        return new SyncPublisher({ ...options, configuration });
+    }
+    /**
+     * Starts (and memoizes per configuration) the sync publisher for a server
+     * boot: no-op when no registered model declares a publish config, guarded so
+     * repeated boots with the same configuration register the publish callbacks
+     * only once.
+     * @param {Configuration} configuration - Configuration owning the registered models.
+     * @returns {Promise<SyncPublisher | null>} Started publisher, or null when no models declare publish.
+     */
+    static async startFromConfiguration(configuration) {
+        const startedPublisher = startedPublishersByConfiguration.get(configuration);
+        if (startedPublisher)
+            return startedPublisher;
+        if (!Object.values(configuration.getModelClasses()).some((modelClass) => publishDeclarationFor(modelClass)))
+            return null;
+        const publisher = new SyncPublisher({ configuration });
+        startedPublishersByConfiguration.set(configuration, publisher);
+        await publisher.start();
+        return publisher;
+    }
+    /**
+     * Registers the publish callbacks for every published resource: server-side
+     * creates and updates (destroys when opted in) upsert a sync change row and
+     * fan out the declared broadcasts once their transaction commits.
+     * @returns {Promise<void>}
+     */
+    async start() {
+        if (this._started)
+            return;
+        this._started = true;
+        for (const resourceConfig of Object.values(this.config.resources)) {
+            for (const operation of resourceConfig.operations) {
+                const callbackName = PUBLISHED_CALLBACK_NAMES[operation];
+                const callback = this.publishedMutationCallback({ operation, resourceConfig });
+                resourceConfig.modelClass[callbackName](callback);
+                this._publishedCallbacks.push({ callback, callbackName, modelClass: resourceConfig.modelClass });
+            }
+        }
+    }
+    /**
+     * Unregisters all publish callbacks (tests, shutdown).
+     * @returns {void}
+     */
+    stop() {
+        for (const { callback, callbackName, modelClass } of this._publishedCallbacks) {
+            modelClass.unregisterLifecycleCallback(callbackName, callback);
+        }
+        this._publishedCallbacks = [];
+        this._started = false;
+    }
+    /**
+     * Builds the lifecycle callback publishing one server-side mutation. The
+     * published payload (declaration `serialize`), event scope, and sync type
+     * are snapshotted at mutation-callback time, so afterSave hooks assigning
+     * unsaved attributes (or any later drift on the record) cannot change what
+     * gets published vs what was committed. Persisting and broadcasting are
+     * deferred through the model connection's afterCommit hook so they only run
+     * once the mutation's transaction has committed (immediately when no
+     * transaction is open) - rolled-back mutations never publish. Post-commit
+     * publish failures are reported without rethrowing into the driver's
+     * afterCommit chain (see reportAfterCommitError).
+     * @param {{operation: "create" | "update" | "destroy", resourceConfig: import("./sync-publisher-types.js").SyncPublisherResourceConfig}} args - Operation and resource config.
+     * @returns {(record: ?) => Promise<void>} Lifecycle callback.
+     */
+    publishedMutationCallback({ operation, resourceConfig }) {
+        return async (record) => {
+            if (isPublishingSuppressed(record))
+                return;
+            const data = await resourceConfig.serialize(record);
+            const resourceId = String(record.id());
+            const syncType = operation === "destroy" ? "delete" : "update";
+            /** @type {Record<string, ?>} */
+            const attributes = {
+                [this.config.actorForeignKeyColumn]: null,
+                client_updated_at: new Date(),
+                data: JSON.stringify(data),
+                resource_id: resourceId,
+                resource_type: resourceConfig.resourceType,
+                sync_type: syncType
+            };
+            if (resourceConfig.eventId) {
+                const eventId = await resourceConfig.eventId(record);
+                attributes.event_id = eventId === undefined || eventId === null ? null : String(eventId);
+            }
+            await resourceConfig.modelClass.connection().afterCommit(async () => {
+                try {
+                    const syncRow = await this.upsertPublishedSyncRow(attributes);
+                    if (resourceConfig.broadcasts) {
+                        await deliverDeclaredBroadcasts({
+                            args: { data, operation, record, resourceId, resourceType: resourceConfig.resourceType, syncRow, syncType },
+                            broadcaster: this.broadcaster(),
+                            broadcasts: resourceConfig.broadcasts
+                        });
+                    }
+                }
+                catch (error) {
+                    await this.reportAfterCommitError(/** @type {Error} */ (error));
+                }
+            });
+        };
+    }
+    /**
+     * Upserts the published server-origin sync row for a resource identity:
+     * server-origin rows carry a null actor column (no device to echo the
+     * change back to), so repeated server changes to one resource reuse and
+     * re-sequence one feed row.
+     * @param {Record<string, ?>} attributes - Snapshotted sync row attributes.
+     * @returns {Promise<?>} Upserted sync row.
+     */
+    async upsertPublishedSyncRow(attributes) {
+        const existingSync = await this.config.syncModel
+            .where({
+            [this.config.actorForeignKeyColumn]: null,
+            resource_id: attributes.resource_id,
+            resource_type: attributes.resource_type
+        })
+            .first();
+        return await upsertSyncRow({ attributes, existingSync, syncModel: this.config.syncModel });
+    }
+    /**
+     * Returns the broadcaster delivering declared broadcasts: the injected one,
+     * or the configuration's channel broadcast awaited through the pending
+     * broadcast queue.
+     * @returns {NonNullable<import("./sync-publisher-types.js").SyncPublisherOptions["broadcaster"]>} Broadcast deliverer.
+     */
+    broadcaster() {
+        if (this.config.broadcaster)
+            return this.config.broadcaster;
+        return async ({ body, channel, params }) => {
+            this.config.configuration.broadcastToChannel(channel, params, body);
+            await this.config.configuration.awaitPendingBroadcasts();
+        };
+    }
+    /**
+     * Reports a post-commit publish failure. The transaction has already
+     * committed when afterCommit callbacks run, so rethrowing here would poison
+     * the driver's awaited afterCommit chain (breaking unrelated callbacks) -
+     * instead the failure goes to the configured onError hook, or is emitted on
+     * the configuration's framework-error/all-error channels (so production bug
+     * reporting via `configuration.getErrorEvents()` sees a broken publish
+     * path) and logged loudly through the publisher's logger when none is
+     * configured.
+     * @param {Error} error - Post-commit publish failure.
+     * @returns {Promise<void>}
+     */
+    async reportAfterCommitError(error) {
+        if (this.config.onError) {
+            this.config.onError(error);
+            return;
+        }
+        const errorEvents = this.config.configuration.getErrorEvents();
+        const payload = { context: { stage: "sync-publish-after-commit" }, error };
+        errorEvents.emit("framework-error", payload);
+        errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+        await this.logger().error("SyncPublisher failed to publish a server-side sync change after commit", error);
+    }
+    /**
+     * Returns the lazily built publisher logger.
+     * @returns {Logger} Publisher logger.
+     */
+    logger() {
+        this._logger ||= new Logger("SyncPublisher", { configuration: this.config.configuration });
+        return this._logger;
+    }
+}
+/**
+ * Resolves a model class's active publish declaration from `static sync`.
+ * Opted-out (`publish: false`) and undeclared models resolve to null; every
+ * other declared value flows into loud declaration validation.
+ * @param {?} modelClass - Registered model class.
+ * @returns {import("./sync-publisher-types.js").SyncPublishDeclarationConfig | null} Active publish declaration, or null.
+ */
+function publishDeclarationFor(modelClass) {
+    const declaration = modelClass.sync;
+    if (!declaration || typeof declaration !== "object" || declaration.publish === undefined || declaration.publish === false)
+        return null;
+    return declaration.publish;
+}
+/**
+ * Builds one published resource config from a model's `static sync` publish
+ * declaration.
+ * @param {{modelClass: ?, publish: import("./sync-publisher-types.js").SyncPublishDeclarationConfig}} args - Declaration args.
+ * @returns {import("./sync-publisher-types.js").SyncPublisherResourceConfig} Derived resource config.
+ */
+function resourceConfigFromPublishDeclaration({ modelClass, publish }) {
+    const modelName = modelClass.getModelName();
+    if (!publish || typeof publish !== "object" || Array.isArray(publish)) {
+        throw new Error(`${modelName} static sync publish must be false or a publish declaration object, got: ${String(publish)}`);
+    }
+    const { broadcasts, eventId, operations, resourceType, serialize, ...restDeclaration } = publish;
+    const unknownKeys = Object.keys(restDeclaration);
+    if (unknownKeys.length > 0) {
+        throw new Error(`${modelName} static sync publish received unknown keys: ${unknownKeys.join(", ")} (supported: broadcasts, eventId, operations, resourceType, serialize)`);
+    }
+    if (typeof serialize !== "function") {
+        throw new Error(`${modelName} static sync publish requires a serialize(record) function building the published payload`);
+    }
+    if (operations !== undefined) {
+        if (!Array.isArray(operations) || operations.length === 0) {
+            throw new Error(`${modelName} static sync publish operations must be a non-empty array of create/update/destroy`);
+        }
+        for (const operation of operations) {
+            if (!(operation in PUBLISHED_CALLBACK_NAMES)) {
+                throw new Error(`${modelName} static sync publish operations must be create/update/destroy, got: ${String(operation)}`);
+            }
+        }
+    }
+    return {
+        broadcasts,
+        eventId,
+        modelClass,
+        operations: operations === undefined ? DEFAULT_PUBLISHED_OPERATIONS : operations,
+        resourceType: resourceType === undefined ? modelName : resourceType,
+        serialize
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-publisher.js","sourceRoot":"","sources":["../../../src/sync/sync-publisher.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,aAAa,MAAM,qBAAqB,CAAA;AAC/C,OAAO,MAAM,MAAM,cAAc,CAAA;AACjC,OAAO,aAAa,MAAM,6BAA6B,CAAA;AAEvD,OAAO,EAAC,yBAAyB,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAA;AAChF,OAAO,EAAC,sBAAsB,EAAC,MAAM,+BAA+B,CAAA;AAEpE,sFAAsF;AACtF,MAAM,wBAAwB,GAAG,EAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,EAAC,CAAA;AAExG;;;;;;oDAMoD;AACpD,MAAM,4BAA4B,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAEzD,oDAAoD;AACpD,MAAM,gCAAgC,GAAG,IAAI,OAAO,EAAE,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC;;;;;;;;OAQG;IACH,YAAY,OAAO,GAAG,EAAE;QACtB,MAAM,EAAC,qBAAqB,GAAG,yBAAyB,EAAE,WAAW,EAAE,aAAa,GAAG,aAAa,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,WAAW,EAAC,GAAG,OAAO,CAAA;QAE7J,aAAa,CAAC,WAAW,CAAC,CAAA;QAE1B,MAAM,YAAY,GAAG,aAAa,CAAC,eAAe,EAAE,CAAA;QACpD,8FAA8F;QAC9F,MAAM,SAAS,GAAG,EAAE,CAAA;QAEpB,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;YACrD,MAAM,OAAO,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAA;YAEjD,IAAI,CAAC,OAAO;gBAAE,SAAQ;YAEtB,MAAM,cAAc,GAAG,oCAAoC,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;YAElF,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC,GAAG,cAAc,CAAA;QACzD,CAAC;QAED,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,iMAAiM,CAAC,CAAA;QACpN,CAAC;QAED,MAAM,iBAAiB,GAAG,SAAS,IAAI,YAAY,CAAC,IAAI,CAAA;QAExD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,+GAA+G,CAAC,CAAA;QAClI,CAAC;QAED,0VAA0V;QAC1V,IAAI,CAAC,MAAM,GAAG,EAAC,qBAAqB,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,iBAAiB,EAAC,CAAA;QACnH,2IAA2I;QAC3I,IAAI,CAAC,mBAAmB,GAAG,EAAE,CAAA;QAC7B,4BAA4B;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QACnB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAA;IACvB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,iBAAiB,CAAC,aAAa,GAAG,aAAa,CAAC,OAAO,EAAE,EAAE,OAAO,GAAG,EAAE;QAC5E,OAAO,IAAI,aAAa,CAAC,EAAC,GAAG,OAAO,EAAE,aAAa,EAAC,CAAC,CAAA;IACvD,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,sBAAsB,CAAC,aAAa;QAC/C,MAAM,gBAAgB,GAAG,gCAAgC,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;QAE5E,IAAI,gBAAgB;YAAE,OAAO,gBAAgB,CAAA;QAE7C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;QAExH,MAAM,SAAS,GAAG,IAAI,aAAa,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;QAEpD,gCAAgC,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,CAAC,CAAA;QAC9D,MAAM,SAAS,CAAC,KAAK,EAAE,CAAA;QAEvB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAM;QAEzB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;QAEpB,KAAK,MAAM,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YAClE,KAAK,MAAM,SAAS,IAAI,cAAc,CAAC,UAAU,EAAE,CAAC;gBAClD,MAAM,YAAY,GAAG,wBAAwB,CAAC,SAAS,CAAC,CAAA;gBACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,yBAAyB,CAAC,EAAC,SAAS,EAAE,cAAc,EAAC,CAAC,CAAA;gBAE5E,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,CAAA;gBACjD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,CAAC,UAAU,EAAC,CAAC,CAAA;YAChG,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,IAAI;QACF,KAAK,MAAM,EAAC,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAC,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC5E,UAAU,CAAC,2BAA2B,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAA;QAChE,CAAC;QAED,IAAI,CAAC,mBAAmB,GAAG,EAAE,CAAA;QAC7B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAA;IACvB,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,yBAAyB,CAAC,EAAC,SAAS,EAAE,cAAc,EAAC;QACnD,OAAO,KAAK,EAAE,MAAM,EAAE,EAAE;YACtB,IAAI,sBAAsB,CAAC,MAAM,CAAC;gBAAE,OAAM;YAE1C,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;YACnD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAA;YACtC,MAAM,QAAQ,GAAG,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAA;YAC9D,gCAAgC;YAChC,MAAM,UAAU,GAAG;gBACjB,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE,IAAI;gBACzC,iBAAiB,EAAE,IAAI,IAAI,EAAE;gBAC7B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;gBAC1B,WAAW,EAAE,UAAU;gBACvB,aAAa,EAAE,cAAc,CAAC,YAAY;gBAC1C,SAAS,EAAE,QAAQ;aACpB,CAAA;YAED,IAAI,cAAc,CAAC,OAAO,EAAE,CAAC;gBAC3B,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;gBAEpD,UAAU,CAAC,QAAQ,GAAG,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAC1F,CAAC;YAED,MAAM,cAAc,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE;gBAClE,IAAI,CAAC;oBACH,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAA;oBAE7D,IAAI,cAAc,CAAC,UAAU,EAAE,CAAC;wBAC9B,MAAM,yBAAyB,CAAC;4BAC9B,IAAI,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,CAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAC;4BACzG,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE;4BAC/B,UAAU,EAAE,cAAc,CAAC,UAAU;yBACtC,CAAC,CAAA;oBACJ,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,IAAI,CAAC,sBAAsB,CAAC,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;gBACjE,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC,CAAA;IACH,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,sBAAsB,CAAC,UAAU;QACrC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS;aAC7C,KAAK,CAAC;YACL,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE,IAAI;YACzC,WAAW,EAAE,UAAU,CAAC,WAAW;YACnC,aAAa,EAAE,UAAU,CAAC,aAAa;SACxC,CAAC;aACD,KAAK,EAAE,CAAA;QAEV,OAAO,MAAM,aAAa,CAAC,EAAC,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,EAAC,CAAC,CAAA;IAC1F,CAAC;IAED;;;;;OAKG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAA;QAE3D,OAAO,KAAK,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAC,EAAE,EAAE;YACvC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;YACnE,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,sBAAsB,EAAE,CAAA;QAC1D,CAAC,CAAA;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,sBAAsB,CAAC,KAAK;QAChC,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;YAE1B,OAAM;QACR,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,EAAE,CAAA;QAC9D,MAAM,OAAO,GAAG,EAAC,OAAO,EAAE,EAAC,KAAK,EAAE,2BAA2B,EAAC,EAAE,KAAK,EAAC,CAAA;QAEtE,WAAW,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAA;QAC5C,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,EAAC,GAAG,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAC,CAAC,CAAA;QAEzE,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,wEAAwE,EAAE,KAAK,CAAC,CAAA;IAC5G,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,IAAI,CAAC,OAAO,KAAK,IAAI,MAAM,CAAC,eAAe,EAAE,EAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAC,CAAC,CAAA;QAExF,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,UAAU;IACvC,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAA;IAEnC,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,CAAC,OAAO,KAAK,SAAS,IAAI,WAAW,CAAC,OAAO,KAAK,KAAK;QAAE,OAAO,IAAI,CAAA;IAEtI,OAAO,WAAW,CAAC,OAAO,CAAA;AAC5B,CAAC;AAED;;;;;GAKG;AACH,SAAS,oCAAoC,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC;IACjE,MAAM,SAAS,GAAG,UAAU,CAAC,YAAY,EAAE,CAAA;IAE3C,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,4EAA4E,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC5H,CAAC;IAED,MAAM,EAAC,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,eAAe,EAAC,GAAG,OAAO,CAAA;IAC9F,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;IAEhD,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,+CAA+C,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,wEAAwE,CAAC,CAAA;IAC5K,CAAC;IACD,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,2FAA2F,CAAC,CAAA;IAC1H,CAAC;IACD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,oFAAoF,CAAC,CAAA;QACnH,CAAC;QAED,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,IAAI,CAAC,CAAC,SAAS,IAAI,wBAAwB,CAAC,EAAE,CAAC;gBAC7C,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,uEAAuE,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAA;YACzH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO;QACL,UAAU;QACV,OAAO;QACP,UAAU;QACV,UAAU,EAAE,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAC,UAAU;QAChF,YAAY,EAAE,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY;QACnE,SAAS;KACV,CAAA;AACH,CAAC","sourcesContent":["// @ts-check\n\nimport Configuration from \"../configuration.js\"\nimport Logger from \"../logger.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\nimport {deliverDeclaredBroadcasts, upsertSyncRow} from \"./sync-change-fanout.js\"\nimport {isPublishingSuppressed} from \"./sync-publish-suppression.js\"\n\n/** @type {{create: \"afterCreate\", update: \"afterUpdate\", destroy: \"afterDestroy\"}} */\nconst PUBLISHED_CALLBACK_NAMES = {create: \"afterCreate\", destroy: \"afterDestroy\", update: \"afterUpdate\"}\n\n/**\n * Operations published by default for models declaring `static sync` publish\n * without an `operations` key: server-side creates and updates publish\n * automatically. Destroys are not published by default because a server\n * destroy is often cleanup rather than a synced delete; opt in with an\n * operations list.\n * @type {Array<\"create\" | \"update\" | \"destroy\">} */\nconst DEFAULT_PUBLISHED_OPERATIONS = [\"create\", \"update\"]\n\n/** @type {WeakMap<Configuration, SyncPublisher>} */\nconst startedPublishersByConfiguration = new WeakMap()\n\n/**\n * Declarative server-side sync publisher — the server mirror of the client's\n * track-by-default mutation tracking.\n *\n * Server models declare what to publish through `static sync`'s `publish`\n * key, and Velocious writes every committed server-side change to the sync\n * change feed (model-backed Sync-row upsert with server re-sequencing) and\n * fans out the declared broadcasts, so devices receive server-origin changes\n * without app code calling manual upsert/broadcast helpers:\n *\n *     static sync = {\n *       publish: {\n *         serialize: (event) => ({id: event.id(), eventPin: event.eventPin()}),\n *         eventId: (event) => event.id(),\n *         broadcasts: [{channel: \"ticket-scans\", broadcastParams: ..., body: ...}]\n *       }\n *     }\n *\n * Replayed device mutations never double-publish: the framework's routed\n * replay apply marks its written records through `markServerApply(record)`\n * (see sync-publish-suppression.js), and app code applying already-synced\n * data can use `markServerApply`/`withoutPublishing` the same way.\n */\nexport default class SyncPublisher {\n  /**\n   * Builds the sync publisher by deriving published resources from the\n   * configuration's registered models: every model declaring `static sync`\n   * with a `publish` declaration becomes a published resource\n   * (`publish: false` opts out). The sync/change model is the registered\n   * \"Sync\" model and broadcasts default to the configuration's channel\n   * broadcast.\n   * @param {import(\"./sync-publisher-types.js\").SyncPublisherOptions} [options] - Optional overrides.\n   */\n  constructor(options = {}) {\n    const {actorForeignKeyColumn = \"authentication_token_id\", broadcaster, configuration = Configuration.current(), onError, syncModel, ...restOptions} = options\n\n    restArgsError(restOptions)\n\n    const modelClasses = configuration.getModelClasses()\n    /** @type {Record<string, import(\"./sync-publisher-types.js\").SyncPublisherResourceConfig>} */\n    const resources = {}\n\n    for (const modelClass of Object.values(modelClasses)) {\n      const publish = publishDeclarationFor(modelClass)\n\n      if (!publish) continue\n\n      const resourceConfig = resourceConfigFromPublishDeclaration({modelClass, publish})\n\n      resources[resourceConfig.resourceType] = resourceConfig\n    }\n\n    if (Object.keys(resources).length === 0) {\n      throw new Error(\"SyncPublisher found no registered models declaring static sync publish - declare `static sync = {publish: {serialize}}` on the models whose server-side changes should publish to the sync feed\")\n    }\n\n    const resolvedSyncModel = syncModel || modelClasses.Sync\n\n    if (!resolvedSyncModel) {\n      throw new Error(\"SyncPublisher requires a registered \\\"Sync\\\" model for published sync change rows (or pass options.syncModel)\")\n    }\n\n    /** @type {{actorForeignKeyColumn: string, broadcaster: import(\"./sync-publisher-types.js\").SyncPublisherOptions[\"broadcaster\"], configuration: Configuration, onError: import(\"./sync-publisher-types.js\").SyncPublisherOptions[\"onError\"], resources: Record<string, import(\"./sync-publisher-types.js\").SyncPublisherResourceConfig>, syncModel: ?}} */\n    this.config = {actorForeignKeyColumn, broadcaster, configuration, onError, resources, syncModel: resolvedSyncModel}\n    /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: \"afterCreate\" | \"afterUpdate\" | \"afterDestroy\", modelClass: ?}>} */\n    this._publishedCallbacks = []\n    /** @type {Logger | null} */\n    this._logger = null\n    this._started = false\n  }\n\n  /**\n   * Builds a sync publisher derived from the given configuration. Alias for\n   * `new SyncPublisher({configuration, ...options})`.\n   * @param {Configuration} [configuration] - Configuration owning the registered models. Defaults to the current configuration.\n   * @param {Omit<import(\"./sync-publisher-types.js\").SyncPublisherOptions, \"configuration\">} [options] - Optional overrides.\n   * @returns {SyncPublisher} Sync publisher derived from the configuration.\n   */\n  static fromConfiguration(configuration = Configuration.current(), options = {}) {\n    return new SyncPublisher({...options, configuration})\n  }\n\n  /**\n   * Starts (and memoizes per configuration) the sync publisher for a server\n   * boot: no-op when no registered model declares a publish config, guarded so\n   * repeated boots with the same configuration register the publish callbacks\n   * only once.\n   * @param {Configuration} configuration - Configuration owning the registered models.\n   * @returns {Promise<SyncPublisher | null>} Started publisher, or null when no models declare publish.\n   */\n  static async startFromConfiguration(configuration) {\n    const startedPublisher = startedPublishersByConfiguration.get(configuration)\n\n    if (startedPublisher) return startedPublisher\n\n    if (!Object.values(configuration.getModelClasses()).some((modelClass) => publishDeclarationFor(modelClass))) return null\n\n    const publisher = new SyncPublisher({configuration})\n\n    startedPublishersByConfiguration.set(configuration, publisher)\n    await publisher.start()\n\n    return publisher\n  }\n\n  /**\n   * Registers the publish callbacks for every published resource: server-side\n   * creates and updates (destroys when opted in) upsert a sync change row and\n   * fan out the declared broadcasts once their transaction commits.\n   * @returns {Promise<void>}\n   */\n  async start() {\n    if (this._started) return\n\n    this._started = true\n\n    for (const resourceConfig of Object.values(this.config.resources)) {\n      for (const operation of resourceConfig.operations) {\n        const callbackName = PUBLISHED_CALLBACK_NAMES[operation]\n        const callback = this.publishedMutationCallback({operation, resourceConfig})\n\n        resourceConfig.modelClass[callbackName](callback)\n        this._publishedCallbacks.push({callback, callbackName, modelClass: resourceConfig.modelClass})\n      }\n    }\n  }\n\n  /**\n   * Unregisters all publish callbacks (tests, shutdown).\n   * @returns {void}\n   */\n  stop() {\n    for (const {callback, callbackName, modelClass} of this._publishedCallbacks) {\n      modelClass.unregisterLifecycleCallback(callbackName, callback)\n    }\n\n    this._publishedCallbacks = []\n    this._started = false\n  }\n\n  /**\n   * Builds the lifecycle callback publishing one server-side mutation. The\n   * published payload (declaration `serialize`), event scope, and sync type\n   * are snapshotted at mutation-callback time, so afterSave hooks assigning\n   * unsaved attributes (or any later drift on the record) cannot change what\n   * gets published vs what was committed. Persisting and broadcasting are\n   * deferred through the model connection's afterCommit hook so they only run\n   * once the mutation's transaction has committed (immediately when no\n   * transaction is open) - rolled-back mutations never publish. Post-commit\n   * publish failures are reported without rethrowing into the driver's\n   * afterCommit chain (see reportAfterCommitError).\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", resourceConfig: import(\"./sync-publisher-types.js\").SyncPublisherResourceConfig}} args - Operation and resource config.\n   * @returns {(record: ?) => Promise<void>} Lifecycle callback.\n   */\n  publishedMutationCallback({operation, resourceConfig}) {\n    return async (record) => {\n      if (isPublishingSuppressed(record)) return\n\n      const data = await resourceConfig.serialize(record)\n      const resourceId = String(record.id())\n      const syncType = operation === \"destroy\" ? \"delete\" : \"update\"\n      /** @type {Record<string, ?>} */\n      const attributes = {\n        [this.config.actorForeignKeyColumn]: null,\n        client_updated_at: new Date(),\n        data: JSON.stringify(data),\n        resource_id: resourceId,\n        resource_type: resourceConfig.resourceType,\n        sync_type: syncType\n      }\n\n      if (resourceConfig.eventId) {\n        const eventId = await resourceConfig.eventId(record)\n\n        attributes.event_id = eventId === undefined || eventId === null ? null : String(eventId)\n      }\n\n      await resourceConfig.modelClass.connection().afterCommit(async () => {\n        try {\n          const syncRow = await this.upsertPublishedSyncRow(attributes)\n\n          if (resourceConfig.broadcasts) {\n            await deliverDeclaredBroadcasts({\n              args: {data, operation, record, resourceId, resourceType: resourceConfig.resourceType, syncRow, syncType},\n              broadcaster: this.broadcaster(),\n              broadcasts: resourceConfig.broadcasts\n            })\n          }\n        } catch (error) {\n          await this.reportAfterCommitError(/** @type {Error} */ (error))\n        }\n      })\n    }\n  }\n\n  /**\n   * Upserts the published server-origin sync row for a resource identity:\n   * server-origin rows carry a null actor column (no device to echo the\n   * change back to), so repeated server changes to one resource reuse and\n   * re-sequence one feed row.\n   * @param {Record<string, ?>} attributes - Snapshotted sync row attributes.\n   * @returns {Promise<?>} Upserted sync row.\n   */\n  async upsertPublishedSyncRow(attributes) {\n    const existingSync = await this.config.syncModel\n      .where({\n        [this.config.actorForeignKeyColumn]: null,\n        resource_id: attributes.resource_id,\n        resource_type: attributes.resource_type\n      })\n      .first()\n\n    return await upsertSyncRow({attributes, existingSync, syncModel: this.config.syncModel})\n  }\n\n  /**\n   * Returns the broadcaster delivering declared broadcasts: the injected one,\n   * or the configuration's channel broadcast awaited through the pending\n   * broadcast queue.\n   * @returns {NonNullable<import(\"./sync-publisher-types.js\").SyncPublisherOptions[\"broadcaster\"]>} Broadcast deliverer.\n   */\n  broadcaster() {\n    if (this.config.broadcaster) return this.config.broadcaster\n\n    return async ({body, channel, params}) => {\n      this.config.configuration.broadcastToChannel(channel, params, body)\n      await this.config.configuration.awaitPendingBroadcasts()\n    }\n  }\n\n  /**\n   * Reports a post-commit publish failure. The transaction has already\n   * committed when afterCommit callbacks run, so rethrowing here would poison\n   * the driver's awaited afterCommit chain (breaking unrelated callbacks) -\n   * instead the failure goes to the configured onError hook, or is emitted on\n   * the configuration's framework-error/all-error channels (so production bug\n   * reporting via `configuration.getErrorEvents()` sees a broken publish\n   * path) and logged loudly through the publisher's logger when none is\n   * configured.\n   * @param {Error} error - Post-commit publish failure.\n   * @returns {Promise<void>}\n   */\n  async reportAfterCommitError(error) {\n    if (this.config.onError) {\n      this.config.onError(error)\n\n      return\n    }\n\n    const errorEvents = this.config.configuration.getErrorEvents()\n    const payload = {context: {stage: \"sync-publish-after-commit\"}, error}\n\n    errorEvents.emit(\"framework-error\", payload)\n    errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n\n    await this.logger().error(\"SyncPublisher failed to publish a server-side sync change after commit\", error)\n  }\n\n  /**\n   * Returns the lazily built publisher logger.\n   * @returns {Logger} Publisher logger.\n   */\n  logger() {\n    this._logger ||= new Logger(\"SyncPublisher\", {configuration: this.config.configuration})\n\n    return this._logger\n  }\n}\n\n/**\n * Resolves a model class's active publish declaration from `static sync`.\n * Opted-out (`publish: false`) and undeclared models resolve to null; every\n * other declared value flows into loud declaration validation.\n * @param {?} modelClass - Registered model class.\n * @returns {import(\"./sync-publisher-types.js\").SyncPublishDeclarationConfig | null} Active publish declaration, or null.\n */\nfunction publishDeclarationFor(modelClass) {\n  const declaration = modelClass.sync\n\n  if (!declaration || typeof declaration !== \"object\" || declaration.publish === undefined || declaration.publish === false) return null\n\n  return declaration.publish\n}\n\n/**\n * Builds one published resource config from a model's `static sync` publish\n * declaration.\n * @param {{modelClass: ?, publish: import(\"./sync-publisher-types.js\").SyncPublishDeclarationConfig}} args - Declaration args.\n * @returns {import(\"./sync-publisher-types.js\").SyncPublisherResourceConfig} Derived resource config.\n */\nfunction resourceConfigFromPublishDeclaration({modelClass, publish}) {\n  const modelName = modelClass.getModelName()\n\n  if (!publish || typeof publish !== \"object\" || Array.isArray(publish)) {\n    throw new Error(`${modelName} static sync publish must be false or a publish declaration object, got: ${String(publish)}`)\n  }\n\n  const {broadcasts, eventId, operations, resourceType, serialize, ...restDeclaration} = publish\n  const unknownKeys = Object.keys(restDeclaration)\n\n  if (unknownKeys.length > 0) {\n    throw new Error(`${modelName} static sync publish received unknown keys: ${unknownKeys.join(\", \")} (supported: broadcasts, eventId, operations, resourceType, serialize)`)\n  }\n  if (typeof serialize !== \"function\") {\n    throw new Error(`${modelName} static sync publish requires a serialize(record) function building the published payload`)\n  }\n  if (operations !== undefined) {\n    if (!Array.isArray(operations) || operations.length === 0) {\n      throw new Error(`${modelName} static sync publish operations must be a non-empty array of create/update/destroy`)\n    }\n\n    for (const operation of operations) {\n      if (!(operation in PUBLISHED_CALLBACK_NAMES)) {\n        throw new Error(`${modelName} static sync publish operations must be create/update/destroy, got: ${String(operation)}`)\n      }\n    }\n  }\n\n  return {\n    broadcasts,\n    eventId,\n    modelClass,\n    operations: operations === undefined ? DEFAULT_PUBLISHED_OPERATIONS : operations,\n    resourceType: resourceType === undefined ? modelName : resourceType,\n    serialize\n  }\n}\n"]}

package/build/src/testing/test-runner.d.ts

@@ -427,6 +427,14 @@ export default class TestRunner {
         passthrough?: boolean | undefined;
     }): () => string;
 }
+/**
+ * Marks the error thrown by {@link runWithTimeout} so the caller can tell a
+ * lifecycle timeout (the promise is still running detached) apart from an
+ * ordinary test failure (the promise already settled).
+ */
+export type TestTimeoutError = Error & {
+    velociousTestTimeout?: true;
+};
 /**
  * AttemptConsoleOutput type.
  */

package/build/src/testing/test-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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"}