velocious 1.0.492 → 1.0.493

package/build/src/sync/sync-replay-upsert-applier.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Declarative field-map upsert applier for sync replay mutations.
+ *
+ * Owns the generic mechanics every per-resource replay handler repeats:
+ * present-key filtering, per-field type coercion, unknown-key rejection, the
+ * find-or-create upsert, the delete branch, optional snapshot serialization,
+ * and the domain after-apply tail. Apps declare only the field map and hooks.
+ */
+export default class SyncReplayUpsertApplier {
+    /**
+     * Creates a declarative upsert applier.
+     * @param {object} args - Applier configuration.
+     * @param {?} args.modelClass - Model class receiving the mutations.
+     * @param {Record<string, string | {type: string, column?: string} | ((value: ?, label: string) => ?)>} args.fields - Data-key → field-type map: a named type, a {type, column} rename spec, "ignored" for accepted-but-dropped keys, or a custom coercer function.
+     * @param {(args: {data: Record<string, ?>, mutation: ?, context: Record<string, ?>}) => Promise<?>} [args.findRecord] - Custom record resolver. Defaults to findBy({id: mutation.resourceId}).
+     * @param {(args: {mutation: ?, context: Record<string, ?>}) => Promise<?>} [args.findRecordForDelete] - Custom delete resolver. Defaults to findRecord.
+     * @param {"error" | "ignore"} [args.restArgs] - Unknown data-key handling. Defaults to "error".
+     * @param {(args: {mappedAttributes: Record<string, ?>, mutation: ?, context: Record<string, ?>, record: ?}) => Promise<Record<string, ?> | void>} [args.afterApply] - Domain tail; its returned object merges into the apply result.
+     * @param {(args: {mutation: ?, context: Record<string, ?>, record: ?}) => Promise<Record<string, ?>> | Record<string, ?>} [args.serialize] - Snapshot serializer; result lands on applyResult.serializedData.
+     */
+    constructor({ afterApply, fields, findRecord, findRecordForDelete, modelClass, restArgs, serialize }: {
+        modelClass: unknown;
+        fields: Record<string, string | {
+            type: string;
+            column?: string;
+        } | ((value: unknown, label: string) => unknown)>;
+        findRecord?: ((args: {
+            data: Record<string, unknown>;
+            mutation: unknown;
+            context: Record<string, unknown>;
+        }) => Promise<unknown>) | undefined;
+        findRecordForDelete?: ((args: {
+            mutation: unknown;
+            context: Record<string, unknown>;
+        }) => Promise<unknown>) | undefined;
+        restArgs?: "error" | "ignore" | undefined;
+        afterApply?: ((args: {
+            mappedAttributes: Record<string, unknown>;
+            mutation: unknown;
+            context: Record<string, unknown>;
+            record: unknown;
+        }) => Promise<Record<string, unknown> | void>) | undefined;
+        serialize?: ((args: {
+            mutation: unknown;
+            context: Record<string, unknown>;
+            record: unknown;
+        }) => Promise<Record<string, unknown>> | Record<string, unknown>) | undefined;
+    });
+    afterApply: ((args: {
+        mappedAttributes: Record<string, unknown>;
+        mutation: unknown;
+        context: Record<string, unknown>;
+        record: unknown;
+    }) => Promise<Record<string, unknown> | void>) | undefined;
+    fields: Record<string, string | {
+        type: string;
+        column?: string;
+    } | ((value: unknown, label: string) => unknown)>;
+    findRecord: ((args: {
+        data: Record<string, unknown>;
+        mutation: unknown;
+        context: Record<string, unknown>;
+    }) => Promise<unknown>) | undefined;
+    findRecordForDelete: ((args: {
+        mutation: unknown;
+        context: Record<string, unknown>;
+    }) => Promise<unknown>) | undefined;
+    modelClass: any;
+    restArgs: "error" | "ignore";
+    serialize: ((args: {
+        mutation: unknown;
+        context: Record<string, unknown>;
+        record: unknown;
+    }) => Promise<Record<string, unknown>> | Record<string, unknown>) | undefined;
+    /**
+     * Applies one normalized replay mutation to the declared model.
+     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: ?}} args - Replay apply arguments.
+     * @returns {Promise<Record<string, ?>>} Apply result with the record, created/deleted flags, optional serializedData, and afterApply extras.
+     */
+    apply({ context, mutation }: {
+        actor: unknown;
+        context: Record<string, unknown>;
+        existingSync: unknown;
+        mutation: unknown;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Applies a delete mutation to the declared model.
+     * @param {{context: Record<string, ?>, mutation: ?}} args - Delete arguments.
+     * @returns {Promise<Record<string, ?>>} Apply result with the deleted flag.
+     */
+    applyDelete({ context, mutation }: {
+        context: Record<string, unknown>;
+        mutation: unknown;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Maps present data keys through the declared field types.
+     * @param {Record<string, ?>} data - Normalized mutation data.
+     * @returns {Record<string, ?>} Coerced attributes keyed by column name.
+     */
+    mappedAttributes(data: Record<string, unknown>): Record<string, unknown>;
+}
+//# sourceMappingURL=sync-replay-upsert-applier.d.ts.map

package/build/src/sync/sync-replay-upsert-applier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-replay-upsert-applier.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-replay-upsert-applier.js"],"names":[],"mappings":"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"}

package/build/src/sync/sync-replay-upsert-applier.js

@@ -0,0 +1,158 @@
+// @ts-check
+import { optionalFloat, optionalInteger, optionalString } from "typanic";
+import SyncApiClient from "./sync-api-client.js";
+/**
+ * Coercers for the declarative sync field types. All are present-key based:
+ * a field is only applied when its key exists in the mutation data.
+ * @type {Record<string, (value: ?, label: string) => ?>}
+ */
+const FIELD_TYPES = {
+    booleanOrNull: (value, label) => SyncApiClient.optionalBooleanSyncValue(value, label),
+    dateOrNull: (value, label) => optionalSyncDate(value, label),
+    floatOrNull: (value, label) => optionalFloat(value, label),
+    integerOrNull: (value, label) => optionalInteger(value, label),
+    raw: (value) => value,
+    stringOrNull: (value, label) => optionalString(value, label)
+};
+/**
+ * Parses an optional date value, failing loudly on invalid input.
+ * @param {?} value - Date, parseable string, or epoch number.
+ * @param {string} label - Field label for error messages.
+ * @returns {Date | null} Parsed date or null when absent.
+ */
+function optionalSyncDate(value, label) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Date && !Number.isNaN(value.getTime()))
+        return value;
+    if (typeof value === "string" || typeof value === "number") {
+        const dateValue = new Date(value);
+        if (!Number.isNaN(dateValue.getTime()))
+            return dateValue;
+    }
+    throw new Error(`Expected ${label} to be a valid date or null`);
+}
+/**
+ * Declarative field-map upsert applier for sync replay mutations.
+ *
+ * Owns the generic mechanics every per-resource replay handler repeats:
+ * present-key filtering, per-field type coercion, unknown-key rejection, the
+ * find-or-create upsert, the delete branch, optional snapshot serialization,
+ * and the domain after-apply tail. Apps declare only the field map and hooks.
+ */
+export default class SyncReplayUpsertApplier {
+    /**
+     * Creates a declarative upsert applier.
+     * @param {object} args - Applier configuration.
+     * @param {?} args.modelClass - Model class receiving the mutations.
+     * @param {Record<string, string | {type: string, column?: string} | ((value: ?, label: string) => ?)>} args.fields - Data-key → field-type map: a named type, a {type, column} rename spec, "ignored" for accepted-but-dropped keys, or a custom coercer function.
+     * @param {(args: {data: Record<string, ?>, mutation: ?, context: Record<string, ?>}) => Promise<?>} [args.findRecord] - Custom record resolver. Defaults to findBy({id: mutation.resourceId}).
+     * @param {(args: {mutation: ?, context: Record<string, ?>}) => Promise<?>} [args.findRecordForDelete] - Custom delete resolver. Defaults to findRecord.
+     * @param {"error" | "ignore"} [args.restArgs] - Unknown data-key handling. Defaults to "error".
+     * @param {(args: {mappedAttributes: Record<string, ?>, mutation: ?, context: Record<string, ?>, record: ?}) => Promise<Record<string, ?> | void>} [args.afterApply] - Domain tail; its returned object merges into the apply result.
+     * @param {(args: {mutation: ?, context: Record<string, ?>, record: ?}) => Promise<Record<string, ?>> | Record<string, ?>} [args.serialize] - Snapshot serializer; result lands on applyResult.serializedData.
+     */
+    constructor({ afterApply, fields, findRecord, findRecordForDelete, modelClass, restArgs = "error", serialize }) {
+        if (!modelClass)
+            throw new Error("SyncReplayUpsertApplier requires a modelClass");
+        if (!fields || typeof fields !== "object")
+            throw new Error("SyncReplayUpsertApplier requires a fields map");
+        if (restArgs !== "error" && restArgs !== "ignore") {
+            throw new Error(`SyncReplayUpsertApplier restArgs must be "error" or "ignore", got: ${String(restArgs)}`);
+        }
+        for (const [fieldName, fieldSpec] of Object.entries(fields)) {
+            if (typeof fieldSpec === "function")
+                continue;
+            const fieldType = typeof fieldSpec === "string" ? fieldSpec : fieldSpec.type;
+            if (fieldType !== "ignored" && !(fieldType in FIELD_TYPES)) {
+                throw new Error(`Unknown sync field type: ${fieldType} for: ${fieldName}`);
+            }
+        }
+        this.afterApply = afterApply;
+        this.fields = fields;
+        this.findRecord = findRecord;
+        this.findRecordForDelete = findRecordForDelete;
+        this.modelClass = modelClass;
+        this.restArgs = restArgs;
+        this.serialize = serialize;
+    }
+    /**
+     * Applies one normalized replay mutation to the declared model.
+     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: ?}} args - Replay apply arguments.
+     * @returns {Promise<Record<string, ?>>} Apply result with the record, created/deleted flags, optional serializedData, and afterApply extras.
+     */
+    async apply({ context, mutation }) {
+        if (mutation.syncType === "delete")
+            return await this.applyDelete({ context, mutation });
+        const mappedAttributes = this.mappedAttributes(mutation.data);
+        const record = this.findRecord
+            ? await this.findRecord({ context, data: mutation.data, mutation })
+            : await this.modelClass.findBy({ id: mutation.resourceId });
+        /** @type {Record<string, ?>} */
+        const result = { created: false, deleted: false, record: null };
+        if (record) {
+            record.assign(mappedAttributes);
+            await record.save();
+            result.record = record;
+        }
+        else {
+            result.record = await this.modelClass.create({ id: mutation.resourceId, ...mappedAttributes });
+            result.created = true;
+        }
+        if (this.serialize)
+            result.serializedData = await this.serialize({ context, mutation, record: result.record });
+        if (this.afterApply) {
+            const afterApplyResult = await this.afterApply({ context, mappedAttributes, mutation, record: result.record });
+            if (afterApplyResult && typeof afterApplyResult === "object")
+                Object.assign(result, afterApplyResult);
+        }
+        return result;
+    }
+    /**
+     * Applies a delete mutation to the declared model.
+     * @param {{context: Record<string, ?>, mutation: ?}} args - Delete arguments.
+     * @returns {Promise<Record<string, ?>>} Apply result with the deleted flag.
+     */
+    async applyDelete({ context, mutation }) {
+        const resolveRecord = this.findRecordForDelete || this.findRecord;
+        const record = resolveRecord
+            ? await resolveRecord({ context, data: mutation.data, mutation })
+            : await this.modelClass.findBy({ id: mutation.resourceId });
+        if (!record)
+            return { created: false, deleted: false, record: null };
+        await record.destroy();
+        return { created: false, deleted: true, record };
+    }
+    /**
+     * Maps present data keys through the declared field types.
+     * @param {Record<string, ?>} data - Normalized mutation data.
+     * @returns {Record<string, ?>} Coerced attributes keyed by column name.
+     */
+    mappedAttributes(data) {
+        /** @type {Record<string, ?>} */
+        const mappedAttributes = {};
+        /** @type {string[]} */
+        const unknownKeys = [];
+        for (const [dataKey, value] of Object.entries(data)) {
+            const fieldSpec = this.fields[dataKey];
+            if (!fieldSpec) {
+                unknownKeys.push(dataKey);
+                continue;
+            }
+            if (typeof fieldSpec === "function") {
+                mappedAttributes[dataKey] = fieldSpec(value, dataKey);
+                continue;
+            }
+            const fieldType = typeof fieldSpec === "string" ? fieldSpec : fieldSpec.type;
+            if (fieldType === "ignored")
+                continue;
+            const column = typeof fieldSpec === "string" ? dataKey : fieldSpec.column || dataKey;
+            mappedAttributes[column] = FIELD_TYPES[fieldType](value, dataKey);
+        }
+        if (unknownKeys.length > 0 && this.restArgs === "error") {
+            throw new Error(`Unknown sync data keys: ${unknownKeys.join(", ")}`);
+        }
+        return mappedAttributes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-replay-upsert-applier.js","sourceRoot":"","sources":["../../../src/sync/sync-replay-upsert-applier.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {optionalFloat, optionalInteger, optionalString} from \"typanic\"\n\nimport SyncApiClient from \"./sync-api-client.js\"\n\n/**\n * Coercers for the declarative sync field types. All are present-key based:\n * a field is only applied when its key exists in the mutation data.\n * @type {Record<string, (value: ?, label: string) => ?>}\n */\nconst FIELD_TYPES = {\n  booleanOrNull: (value, label) => SyncApiClient.optionalBooleanSyncValue(value, label),\n  dateOrNull: (value, label) => optionalSyncDate(value, label),\n  floatOrNull: (value, label) => optionalFloat(value, label),\n  integerOrNull: (value, label) => optionalInteger(value, label),\n  raw: (value) => value,\n  stringOrNull: (value, label) => optionalString(value, label)\n}\n\n/**\n * Parses an optional date value, failing loudly on invalid input.\n * @param {?} value - Date, parseable string, or epoch number.\n * @param {string} label - Field label for error messages.\n * @returns {Date | null} Parsed date or null when absent.\n */\nfunction optionalSyncDate(value, label) {\n  if (value === null || value === undefined) return null\n\n  if (value instanceof Date && !Number.isNaN(value.getTime())) return value\n\n  if (typeof value === \"string\" || typeof value === \"number\") {\n    const dateValue = new Date(value)\n\n    if (!Number.isNaN(dateValue.getTime())) return dateValue\n  }\n\n  throw new Error(`Expected ${label} to be a valid date or null`)\n}\n\n/**\n * Declarative field-map upsert applier for sync replay mutations.\n *\n * Owns the generic mechanics every per-resource replay handler repeats:\n * present-key filtering, per-field type coercion, unknown-key rejection, the\n * find-or-create upsert, the delete branch, optional snapshot serialization,\n * and the domain after-apply tail. Apps declare only the field map and hooks.\n */\nexport default class SyncReplayUpsertApplier {\n  /**\n   * Creates a declarative upsert applier.\n   * @param {object} args - Applier configuration.\n   * @param {?} args.modelClass - Model class receiving the mutations.\n   * @param {Record<string, string | {type: string, column?: string} | ((value: ?, label: string) => ?)>} args.fields - Data-key → field-type map: a named type, a {type, column} rename spec, \"ignored\" for accepted-but-dropped keys, or a custom coercer function.\n   * @param {(args: {data: Record<string, ?>, mutation: ?, context: Record<string, ?>}) => Promise<?>} [args.findRecord] - Custom record resolver. Defaults to findBy({id: mutation.resourceId}).\n   * @param {(args: {mutation: ?, context: Record<string, ?>}) => Promise<?>} [args.findRecordForDelete] - Custom delete resolver. Defaults to findRecord.\n   * @param {\"error\" | \"ignore\"} [args.restArgs] - Unknown data-key handling. Defaults to \"error\".\n   * @param {(args: {mappedAttributes: Record<string, ?>, mutation: ?, context: Record<string, ?>, record: ?}) => Promise<Record<string, ?> | void>} [args.afterApply] - Domain tail; its returned object merges into the apply result.\n   * @param {(args: {mutation: ?, context: Record<string, ?>, record: ?}) => Promise<Record<string, ?>> | Record<string, ?>} [args.serialize] - Snapshot serializer; result lands on applyResult.serializedData.\n   */\n  constructor({afterApply, fields, findRecord, findRecordForDelete, modelClass, restArgs = \"error\", serialize}) {\n    if (!modelClass) throw new Error(\"SyncReplayUpsertApplier requires a modelClass\")\n    if (!fields || typeof fields !== \"object\") throw new Error(\"SyncReplayUpsertApplier requires a fields map\")\n    if (restArgs !== \"error\" && restArgs !== \"ignore\") {\n      throw new Error(`SyncReplayUpsertApplier restArgs must be \"error\" or \"ignore\", got: ${String(restArgs)}`)\n    }\n\n    for (const [fieldName, fieldSpec] of Object.entries(fields)) {\n      if (typeof fieldSpec === \"function\") continue\n\n      const fieldType = typeof fieldSpec === \"string\" ? fieldSpec : fieldSpec.type\n\n      if (fieldType !== \"ignored\" && !(fieldType in FIELD_TYPES)) {\n        throw new Error(`Unknown sync field type: ${fieldType} for: ${fieldName}`)\n      }\n    }\n\n    this.afterApply = afterApply\n    this.fields = fields\n    this.findRecord = findRecord\n    this.findRecordForDelete = findRecordForDelete\n    this.modelClass = modelClass\n    this.restArgs = restArgs\n    this.serialize = serialize\n  }\n\n  /**\n   * Applies one normalized replay mutation to the declared model.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: ?}} args - Replay apply arguments.\n   * @returns {Promise<Record<string, ?>>} Apply result with the record, created/deleted flags, optional serializedData, and afterApply extras.\n   */\n  async apply({context, mutation}) {\n    if (mutation.syncType === \"delete\") return await this.applyDelete({context, mutation})\n\n    const mappedAttributes = this.mappedAttributes(mutation.data)\n    const record = this.findRecord\n      ? await this.findRecord({context, data: mutation.data, mutation})\n      : await this.modelClass.findBy({id: mutation.resourceId})\n    /** @type {Record<string, ?>} */\n    const result = {created: false, deleted: false, record: null}\n\n    if (record) {\n      record.assign(mappedAttributes)\n      await record.save()\n      result.record = record\n    } else {\n      result.record = await this.modelClass.create({id: mutation.resourceId, ...mappedAttributes})\n      result.created = true\n    }\n\n    if (this.serialize) result.serializedData = await this.serialize({context, mutation, record: result.record})\n\n    if (this.afterApply) {\n      const afterApplyResult = await this.afterApply({context, mappedAttributes, mutation, record: result.record})\n\n      if (afterApplyResult && typeof afterApplyResult === \"object\") Object.assign(result, afterApplyResult)\n    }\n\n    return result\n  }\n\n  /**\n   * Applies a delete mutation to the declared model.\n   * @param {{context: Record<string, ?>, mutation: ?}} args - Delete arguments.\n   * @returns {Promise<Record<string, ?>>} Apply result with the deleted flag.\n   */\n  async applyDelete({context, mutation}) {\n    const resolveRecord = this.findRecordForDelete || this.findRecord\n    const record = resolveRecord\n      ? await resolveRecord({context, data: mutation.data, mutation})\n      : await this.modelClass.findBy({id: mutation.resourceId})\n\n    if (!record) return {created: false, deleted: false, record: null}\n\n    await record.destroy()\n\n    return {created: false, deleted: true, record}\n  }\n\n  /**\n   * Maps present data keys through the declared field types.\n   * @param {Record<string, ?>} data - Normalized mutation data.\n   * @returns {Record<string, ?>} Coerced attributes keyed by column name.\n   */\n  mappedAttributes(data) {\n    /** @type {Record<string, ?>} */\n    const mappedAttributes = {}\n    /** @type {string[]} */\n    const unknownKeys = []\n\n    for (const [dataKey, value] of Object.entries(data)) {\n      const fieldSpec = this.fields[dataKey]\n\n      if (!fieldSpec) {\n        unknownKeys.push(dataKey)\n        continue\n      }\n\n      if (typeof fieldSpec === \"function\") {\n        mappedAttributes[dataKey] = fieldSpec(value, dataKey)\n        continue\n      }\n\n      const fieldType = typeof fieldSpec === \"string\" ? fieldSpec : fieldSpec.type\n\n      if (fieldType === \"ignored\") continue\n\n      const column = typeof fieldSpec === \"string\" ? dataKey : fieldSpec.column || dataKey\n\n      mappedAttributes[column] = FIELD_TYPES[fieldType](value, dataKey)\n    }\n\n    if (unknownKeys.length > 0 && this.restArgs === \"error\") {\n      throw new Error(`Unknown sync data keys: ${unknownKeys.join(\", \")}`)\n    }\n\n    return mappedAttributes\n  }\n}\n"]}

package/build/sync/sync-envelope-replay-service.js

@@ -1,5 +1,16 @@
 // @ts-check
 
+import SyncReplayUpsertApplier from "./sync-replay-upsert-applier.js"
+
+/**
+ * One declarative broadcast fanned out after a mutation applies.
+ * @typedef {object} SyncReplayBroadcast
+ * @property {string | ((args: Record<string, ?>) => string)} channel - Channel name or resolver.
+ * @property {(args: Record<string, ?>) => Record<string, ?>} broadcastParams - Channel routing params.
+ * @property {(args: Record<string, ?>) => ?} body - Broadcast body.
+ * @property {(args: Record<string, ?>) => boolean} [when] - Optional gate; skipped when it returns false.
+ */
+
 /**
  * Replays client sync envelopes through project supplied authentication,
  * authorization, application, and persistence hooks.
@@ -23,15 +34,49 @@ export default class SyncEnvelopeReplayService {
    * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.
    * @param {?} [args.syncModel] - Sync/change model enabling model-backed default hooks.
    * @param {string} [args.actorForeignKeyColumn] - Sync model column linking rows to the replay actor.
+   * @param {?} [args.authenticationTokenModel] - Token model enabling the default token-lookup authenticateReplay.
+   * @param {string} [args.authenticationTokenColumn] - Token model column holding the token. Defaults to "token".
+   * @param {string} [args.authenticationTokenParam] - Request param carrying the token. Defaults to "authenticationToken".
+   * @param {Record<string, ((args: Record<string, ?>) => Promise<?>) | ConstructorParameters<typeof SyncReplayUpsertApplier>[0]>} [args.applyHandlers] - Per-resourceType apply handlers (functions or declarative upsert-applier specs) enabling the default applyReplayMutation dispatch.
+   * @param {(args: Record<string, ?>) => Record<string, ?>} [args.persistExtraAttributes] - Extra attributes merged into the model-backed persisted row (e.g. an event scope column).
+   * @param {(args: {mutation: ?, applyResult: ?}) => ?} [args.persistSerializedData] - Overrides the persisted data payload (object results are JSON stringified).
+   * @param {(broadcast: {channel: string, params: Record<string, ?>, body: ?}) => Promise<void>} [args.broadcaster] - Delivers declarative broadcasts. Required when broadcasts are configured.
+   * @param {SyncReplayBroadcast[]} [args.broadcasts] - Broadcasts fanned out by the default afterReplayMutation.
    */
   constructor(args = {}) {
     this.logger = args.logger || console
     this.syncModel = args.syncModel || null
     this.actorForeignKeyColumn = args.actorForeignKeyColumn || "authentication_token_id"
+    this.authenticationTokenModel = args.authenticationTokenModel || null
+    this.authenticationTokenColumn = args.authenticationTokenColumn || "token"
+    this.authenticationTokenParam = args.authenticationTokenParam || "authenticationToken"
+    this.persistExtraAttributes = args.persistExtraAttributes || null
+    this.persistSerializedData = args.persistSerializedData || null
+    this.broadcaster = args.broadcaster || null
+    this.broadcasts = args.broadcasts || null
+    this.applyHandlers = args.applyHandlers ? this.builtApplyHandlers(args.applyHandlers) : null
 
     if (args.actorForeignKeyColumn !== undefined && (typeof args.actorForeignKeyColumn !== "string" || args.actorForeignKeyColumn.length < 1)) {
       throw new Error(`actorForeignKeyColumn must be a non-blank string, got: ${String(args.actorForeignKeyColumn)}`)
     }
+    if (this.broadcasts && !this.broadcaster) {
+      throw new Error("SyncEnvelopeReplayService broadcasts require a broadcaster option delivering them")
+    }
+  }
+
+  /**
+   * Wraps declarative apply-handler specs in upsert appliers.
+   * @param {Record<string, ?>} applyHandlers - Raw apply handlers.
+   * @returns {Record<string, (args: Record<string, ?>) => Promise<?>>} Callable handlers by resource type.
+   */
+  builtApplyHandlers(applyHandlers) {
+    return Object.fromEntries(Object.entries(applyHandlers).map(([resourceType, handler]) => {
+      if (typeof handler === "function") return [resourceType, handler]
+
+      const applier = new SyncReplayUpsertApplier(handler)
+
+      return [resourceType, (/** @type {Record<string, ?>} */ applyArgs) => applier.apply(/** @type {?} */ (applyArgs))]
+    }))
   }
 
   /**
@@ -91,11 +136,30 @@ export default class SyncEnvelopeReplayService {
 
   /**
    * Authenticates the sync batch actor.
-   * @param {Record<string, ?>} _params - Request params.
+   *
+   * Defaults to a token-model lookup when `authenticationTokenModel` is
+   * configured; otherwise apps override this hook.
+   * @param {Record<string, ?>} params - Request params.
    * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.
    */
-  async authenticateReplay(_params) {
-    throw new Error("SyncEnvelopeReplayService.authenticateReplay must be implemented")
+  async authenticateReplay(params) {
+    if (!this.authenticationTokenModel) {
+      throw new Error("SyncEnvelopeReplayService.authenticateReplay must be implemented (or configure authenticationTokenModel)")
+    }
+
+    const token = params[this.authenticationTokenParam]
+
+    if (!token) {
+      return {authenticated: false, errorCode: "missing-authentication-token", errorMessage: "Missing authentication token"}
+    }
+
+    const actor = await this.authenticationTokenModel.findBy({[this.authenticationTokenColumn]: token})
+
+    if (!actor) {
+      return {authenticated: false, errorCode: "invalid-authentication-token", errorMessage: "Invalid authentication token"}
+    }
+
+    return {actor, authenticated: true}
   }
 
   /**
@@ -257,11 +321,20 @@ export default class SyncEnvelopeReplayService {
 
   /**
    * Applies one normalized mutation to domain models.
-   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.
+   *
+   * Defaults to dispatching through the configured apply-handler registry;
+   * mutations without a registered handler fail loudly.
+   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
    * @returns {Promise<?>} Project-specific apply result.
    */
-  async applyReplayMutation(_args) {
-    return null
+  async applyReplayMutation(args) {
+    if (!this.applyHandlers) return null
+
+    const applyHandler = this.applyHandlers[args.mutation.resourceType]
+
+    if (!applyHandler) throw new Error(`No sync apply handler registered for: ${args.mutation.resourceType}`)
+
+    return await applyHandler(args)
   }
 
   /**
@@ -281,11 +354,25 @@ export default class SyncEnvelopeReplayService {
    * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.
    * @returns {Promise<void>}
    */
-  async persistReplayMutation({actor, existingSync, mutation}) {
+  async persistReplayMutation({actor, applyResult, context, existingSync, mutation, shouldApply}) {
     if (!this.syncModel) return
 
     const attributes = this.replayPersistAttributes({actor, mutation})
 
+    // Stale replays never applied anything, so the applyResult-driven extension
+    // hooks must not run against the default null skipped result.
+    if (this.persistExtraAttributes && shouldApply) {
+      Object.assign(attributes, this.persistExtraAttributes({actor, applyResult, context, existingSync, mutation, shouldApply}))
+    }
+
+    if (this.persistSerializedData && shouldApply) {
+      const serializedData = this.persistSerializedData({applyResult, mutation})
+
+      if (serializedData !== undefined && serializedData !== null) {
+        attributes.data = typeof serializedData === "string" ? serializedData : JSON.stringify(serializedData)
+      }
+    }
+
     if (existingSync) {
       const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)
 
@@ -317,10 +404,28 @@ export default class SyncEnvelopeReplayService {
 
   /**
    * Runs side effects after a successful mutation replay and persistence.
-   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} _args - Replay side-effect arguments.
+   *
+   * Defaults to fanning the applied result out through the configured
+   * declarative broadcasts.
+   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay side-effect arguments.
    * @returns {Promise<void>}
    */
-  async afterReplayMutation(_args) {}
+  async afterReplayMutation(args) {
+    if (!this.broadcasts || !this.broadcaster) return
+    // Stale replays never applied anything - broadcasting their skipped results
+    // would fan out stale side effects (or crash on the default null applyResult).
+    if (!args.shouldApply) return
+
+    for (const broadcast of this.broadcasts) {
+      if (broadcast.when && !broadcast.when(args)) continue
+
+      await this.broadcaster({
+        body: broadcast.body(args),
+        channel: typeof broadcast.channel === "function" ? broadcast.channel(args) : broadcast.channel,
+        params: broadcast.broadcastParams(args)
+      })
+    }
+  }
 }
 
 /**