velocious 1.0.489 → 1.0.492

package/build/src/sync/sync-api-controller.js

@@ -1,6 +1,8 @@
 // @ts-check
 import Controller from "../controller.js";
 import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js";
+/** Configurations whose sync.api routes have already been mounted. */
+const mountedConfigurations = new WeakSet();
 /**
  * Generic `/velocious/sync` transport controller.
  *
@@ -87,6 +89,20 @@ export default class SyncApiController extends Controller {
             routes.post(`${at}/replay`, { to: [ControllerClass, "replay"] });
         });
     }
+    /**
+     * Auto-mounts the sync endpoints configured through `sync.api` on a configuration.
+     * No-op when `sync.api` is absent; guarded so repeated server boots with the
+     * same configuration register the routes only once.
+     * @param {import("../configuration.js").default} configuration - Configuration instance.
+     * @returns {void}
+     */
+    static mountFromConfiguration(configuration) {
+        const api = configuration.getSyncConfiguration().api;
+        if (!api || mountedConfigurations.has(configuration))
+            return;
+        mountedConfigurations.add(configuration);
+        this.mountInto({ at: api.mountPath, configuration, syncResourceClass: api.resourceClass });
+    }
     /**
      * Normalizes a sync mount path.
      * @param {string} at - Mount path.
@@ -139,4 +155,4 @@ export default class SyncApiController extends Controller {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-api-controller.js","sourceRoot":"","sources":["../../../src/sync/sync-api-controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Controller from \"../controller.js\"\nimport FrontendModelBaseResource from \"../frontend-model-resource/base-resource.js\"\n\n/**\n * Generic `/velocious/sync` transport controller.\n *\n * Apps provide a sync resource class; Velocious owns endpoint shape and\n * rendering. The app resource owns auth, scoping, and domain-specific\n * replay/change hooks.\n */\nexport default class SyncApiController extends Controller {\n  /**\n   * Renders a replay response from the configured sync resource.\n   * @returns {Promise<void>}\n   */\n  async replay() {\n    const resource = /** @type {FrontendModelBaseResource & {replay: () => Promise<unknown>}} */ (this.syncResource(this.params()))\n\n    await this.render({json: /** @type {object} */ (await resource.replay())})\n  }\n\n  /**\n   * Renders a change-feed response from the configured sync resource.\n   * @returns {Promise<void>}\n   */\n  async changes() {\n    const resource = /** @type {FrontendModelBaseResource & {changes: () => Promise<unknown>}} */ (this.syncResource(this.params()))\n\n    await this.render({json: /** @type {object} */ (await resource.changes())})\n  }\n\n  /**\n   * Builds the sync resource that backs the transport endpoint.\n   * @param {Record<string, unknown>} params - Request params/body.\n   * @returns {FrontendModelBaseResource} Sync resource instance.\n   */\n  syncResource(params) {\n    const ResourceClass = this.syncResourceClass()\n    const ability = this.currentAbility()\n\n    return new ResourceClass({\n      ability,\n      controller: /** @type {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceController} */ (/** @type {unknown} */ (this)),\n      context: {\n        ...(ability?.getContext() || {}),\n        params: this.params(),\n        request: this.request()\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: this.syncModelClass(),\n      modelName: this.syncModelName(),\n      params: /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (params)),\n      resourceConfiguration: this.syncResourceConfiguration(ResourceClass)\n    })\n  }\n\n  /**\n   * Returns the app-provided sync resource class.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n   */\n  syncResourceClass() {\n    return this.missingSyncResourceClass()\n  }\n\n  /**\n   * Builds a sync API controller class bound to the given resource.\n   * @param {import(\"../configuration-types.js\").FrontendModelResourceClassType} ResourceClass - Sync resource class.\n   * @returns {typeof SyncApiController} Controller class for the resource.\n   */\n  static withSyncResourceClass(ResourceClass) {\n    return class ConfiguredSyncApiController extends this {\n      /**\n       * Returns the configured sync resource class.\n       * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n       */\n      syncResourceClass() {\n        return ResourceClass\n      }\n    }\n  }\n\n  /**\n   * Mounts the standard Velocious sync endpoints into a route configuration.\n   * @param {{configuration?: import(\"../configuration.js\").default, at?: string, syncResourceClass?: import(\"../configuration-types.js\").FrontendModelResourceClassType}} args - Mount args.\n   * @returns {void}\n   */\n  static mountInto(args) {\n    const {configuration, syncResourceClass} = args\n    const ControllerClass = syncResourceClass ? this.withSyncResourceClass(syncResourceClass) : this\n    const at = this.normalizedMountPath(args.at || \"/velocious/sync\")\n\n    if (!configuration) throw new Error(\"SyncApiController.mountInto requires configuration\")\n\n    configuration.routes((routes) => {\n      routes.post(`${at}/changes`, {to: [ControllerClass, \"changes\"]})\n      routes.post(`${at}/replay`, {to: [ControllerClass, \"replay\"]})\n    })\n  }\n\n  /**\n   * Normalizes a sync mount path.\n   * @param {string} at - Mount path.\n   * @returns {string} Normalized mount path without trailing slash.\n   */\n  static normalizedMountPath(at) {\n    if (typeof at !== \"string\" || !at.startsWith(\"/\")) {\n      throw new Error(`SyncApiController mount path must start with '/', got: ${String(at)}`)\n    }\n\n    return at.replace(/\\/+$/u, \"\") || \"/\"\n  }\n\n  /**\n   * Raises a configuration error for subclasses that do not provide a resource.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n   */\n  missingSyncResourceClass() {\n    return /** @type {typeof FrontendModelBaseResource} */ (/** @type {unknown} */ (this.raiseMissingSyncResourceClass()))\n  }\n\n  /** Raises a configuration error for subclasses that do not provide a resource. */\n  raiseMissingSyncResourceClass() {\n    throw new Error(\"SyncApiController.syncResourceClass must be implemented\")\n  }\n\n  /**\n   * Returns the model class exposed by the sync resource.\n   * @returns {typeof import(\"../database/record/index.js\").default} Sync model class.\n   */\n  syncModelClass() {\n    const ResourceClass = this.syncResourceClass()\n    const modelClass = ResourceClass.ModelClass\n\n    if (!modelClass) throw new Error(\"Sync resource class must define static ModelClass\")\n\n    return modelClass\n  }\n\n  /**\n   * Returns the model name used to initialize the resource.\n   * @returns {string} Sync model name.\n   */\n  syncModelName() {\n    return this.syncModelClass().name\n  }\n\n  /**\n   * Builds the minimal resource configuration needed by the sync resource.\n   * @param {import(\"../configuration-types.js\").FrontendModelResourceClassType} ResourceClass - Sync resource class.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} Resource configuration.\n   */\n  syncResourceConfiguration(ResourceClass) {\n    return /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n      attributes: ResourceClass.attributes || {},\n      sync: {enabled: true}\n    })\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-api-controller.js","sourceRoot":"","sources":["../../../src/sync/sync-api-controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Controller from \"../controller.js\"\nimport FrontendModelBaseResource from \"../frontend-model-resource/base-resource.js\"\n\n/** Configurations whose sync.api routes have already been mounted. */\nconst mountedConfigurations = new WeakSet()\n\n/**\n * Generic `/velocious/sync` transport controller.\n *\n * Apps provide a sync resource class; Velocious owns endpoint shape and\n * rendering. The app resource owns auth, scoping, and domain-specific\n * replay/change hooks.\n */\nexport default class SyncApiController extends Controller {\n  /**\n   * Renders a replay response from the configured sync resource.\n   * @returns {Promise<void>}\n   */\n  async replay() {\n    const resource = /** @type {FrontendModelBaseResource & {replay: () => Promise<unknown>}} */ (this.syncResource(this.params()))\n\n    await this.render({json: /** @type {object} */ (await resource.replay())})\n  }\n\n  /**\n   * Renders a change-feed response from the configured sync resource.\n   * @returns {Promise<void>}\n   */\n  async changes() {\n    const resource = /** @type {FrontendModelBaseResource & {changes: () => Promise<unknown>}} */ (this.syncResource(this.params()))\n\n    await this.render({json: /** @type {object} */ (await resource.changes())})\n  }\n\n  /**\n   * Builds the sync resource that backs the transport endpoint.\n   * @param {Record<string, unknown>} params - Request params/body.\n   * @returns {FrontendModelBaseResource} Sync resource instance.\n   */\n  syncResource(params) {\n    const ResourceClass = this.syncResourceClass()\n    const ability = this.currentAbility()\n\n    return new ResourceClass({\n      ability,\n      controller: /** @type {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceController} */ (/** @type {unknown} */ (this)),\n      context: {\n        ...(ability?.getContext() || {}),\n        params: this.params(),\n        request: this.request()\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: this.syncModelClass(),\n      modelName: this.syncModelName(),\n      params: /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (params)),\n      resourceConfiguration: this.syncResourceConfiguration(ResourceClass)\n    })\n  }\n\n  /**\n   * Returns the app-provided sync resource class.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n   */\n  syncResourceClass() {\n    return this.missingSyncResourceClass()\n  }\n\n  /**\n   * Builds a sync API controller class bound to the given resource.\n   * @param {import(\"../configuration-types.js\").FrontendModelResourceClassType} ResourceClass - Sync resource class.\n   * @returns {typeof SyncApiController} Controller class for the resource.\n   */\n  static withSyncResourceClass(ResourceClass) {\n    return class ConfiguredSyncApiController extends this {\n      /**\n       * Returns the configured sync resource class.\n       * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n       */\n      syncResourceClass() {\n        return ResourceClass\n      }\n    }\n  }\n\n  /**\n   * Mounts the standard Velocious sync endpoints into a route configuration.\n   * @param {{configuration?: import(\"../configuration.js\").default, at?: string, syncResourceClass?: import(\"../configuration-types.js\").FrontendModelResourceClassType}} args - Mount args.\n   * @returns {void}\n   */\n  static mountInto(args) {\n    const {configuration, syncResourceClass} = args\n    const ControllerClass = syncResourceClass ? this.withSyncResourceClass(syncResourceClass) : this\n    const at = this.normalizedMountPath(args.at || \"/velocious/sync\")\n\n    if (!configuration) throw new Error(\"SyncApiController.mountInto requires configuration\")\n\n    configuration.routes((routes) => {\n      routes.post(`${at}/changes`, {to: [ControllerClass, \"changes\"]})\n      routes.post(`${at}/replay`, {to: [ControllerClass, \"replay\"]})\n    })\n  }\n\n  /**\n   * Auto-mounts the sync endpoints configured through `sync.api` on a configuration.\n   * No-op when `sync.api` is absent; guarded so repeated server boots with the\n   * same configuration register the routes only once.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {void}\n   */\n  static mountFromConfiguration(configuration) {\n    const api = configuration.getSyncConfiguration().api\n\n    if (!api || mountedConfigurations.has(configuration)) return\n\n    mountedConfigurations.add(configuration)\n\n    this.mountInto({at: api.mountPath, configuration, syncResourceClass: api.resourceClass})\n  }\n\n  /**\n   * Normalizes a sync mount path.\n   * @param {string} at - Mount path.\n   * @returns {string} Normalized mount path without trailing slash.\n   */\n  static normalizedMountPath(at) {\n    if (typeof at !== \"string\" || !at.startsWith(\"/\")) {\n      throw new Error(`SyncApiController mount path must start with '/', got: ${String(at)}`)\n    }\n\n    return at.replace(/\\/+$/u, \"\") || \"/\"\n  }\n\n  /**\n   * Raises a configuration error for subclasses that do not provide a resource.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n   */\n  missingSyncResourceClass() {\n    return /** @type {typeof FrontendModelBaseResource} */ (/** @type {unknown} */ (this.raiseMissingSyncResourceClass()))\n  }\n\n  /** Raises a configuration error for subclasses that do not provide a resource. */\n  raiseMissingSyncResourceClass() {\n    throw new Error(\"SyncApiController.syncResourceClass must be implemented\")\n  }\n\n  /**\n   * Returns the model class exposed by the sync resource.\n   * @returns {typeof import(\"../database/record/index.js\").default} Sync model class.\n   */\n  syncModelClass() {\n    const ResourceClass = this.syncResourceClass()\n    const modelClass = ResourceClass.ModelClass\n\n    if (!modelClass) throw new Error(\"Sync resource class must define static ModelClass\")\n\n    return modelClass\n  }\n\n  /**\n   * Returns the model name used to initialize the resource.\n   * @returns {string} Sync model name.\n   */\n  syncModelName() {\n    return this.syncModelClass().name\n  }\n\n  /**\n   * Builds the minimal resource configuration needed by the sync resource.\n   * @param {import(\"../configuration-types.js\").FrontendModelResourceClassType} ResourceClass - Sync resource class.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} Resource configuration.\n   */\n  syncResourceConfiguration(ResourceClass) {\n    return /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n      attributes: ResourceClass.attributes || {},\n      sync: {enabled: true}\n    })\n  }\n}\n\n"]}

package/build/src/sync/sync-client-registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Registers the current sync client.
+ * @param {?} client - Configured sync client (or null to clear).
+ * @returns {void}
+ */
+export function setCurrentSyncClient(client: unknown): void;
+/**
+ * Returns the current sync client.
+ * @returns {?} Current sync client.
+ */
+export function currentSyncClient(): unknown;
+//# sourceMappingURL=sync-client-registry.d.ts.map

package/build/src/sync/sync-client-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-client-registry.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client-registry.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,6CAHW,OAAC,GACC,IAAI,CAIhB;AAED;;;GAGG;AACH,qCAFa,OAAC,CAMb"}

package/build/src/sync/sync-client-registry.js

@@ -0,0 +1,27 @@
+// @ts-check
+/**
+ * Registry for the app's current sync client.
+ *
+ * Kept dependency-free so client-bundled modules (like the query layer) can
+ * delegate to a configured sync client without importing the sync stack.
+ */
+/** @type {?} */
+let currentClient = null;
+/**
+ * Registers the current sync client.
+ * @param {?} client - Configured sync client (or null to clear).
+ * @returns {void}
+ */
+export function setCurrentSyncClient(client) {
+    currentClient = client;
+}
+/**
+ * Returns the current sync client.
+ * @returns {?} Current sync client.
+ */
+export function currentSyncClient() {
+    if (!currentClient)
+        throw new Error("No sync client configured - create a SyncClient and call setCurrent() on it first");
+    return currentClient;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy1jbGllbnQtcmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3luYy9zeW5jLWNsaWVudC1yZWdpc3RyeS5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVo7Ozs7O0dBS0c7QUFFSCxnQkFBZ0I7QUFDaEIsSUFBSSxhQUFhLEdBQUcsSUFBSSxDQUFBO0FBRXhCOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsTUFBTTtJQUN6QyxhQUFhLEdBQUcsTUFBTSxDQUFBO0FBQ3hCLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCO0lBQy9CLElBQUksQ0FBQyxhQUFhO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxtRkFBbUYsQ0FBQyxDQUFBO0lBRXhILE9BQU8sYUFBYSxDQUFBO0FBQ3RCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuLyoqXG4gKiBSZWdpc3RyeSBmb3IgdGhlIGFwcCdzIGN1cnJlbnQgc3luYyBjbGllbnQuXG4gKlxuICogS2VwdCBkZXBlbmRlbmN5LWZyZWUgc28gY2xpZW50LWJ1bmRsZWQgbW9kdWxlcyAobGlrZSB0aGUgcXVlcnkgbGF5ZXIpIGNhblxuICogZGVsZWdhdGUgdG8gYSBjb25maWd1cmVkIHN5bmMgY2xpZW50IHdpdGhvdXQgaW1wb3J0aW5nIHRoZSBzeW5jIHN0YWNrLlxuICovXG5cbi8qKiBAdHlwZSB7P30gKi9cbmxldCBjdXJyZW50Q2xpZW50ID0gbnVsbFxuXG4vKipcbiAqIFJlZ2lzdGVycyB0aGUgY3VycmVudCBzeW5jIGNsaWVudC5cbiAqIEBwYXJhbSB7P30gY2xpZW50IC0gQ29uZmlndXJlZCBzeW5jIGNsaWVudCAob3IgbnVsbCB0byBjbGVhcikuXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldEN1cnJlbnRTeW5jQ2xpZW50KGNsaWVudCkge1xuICBjdXJyZW50Q2xpZW50ID0gY2xpZW50XG59XG5cbi8qKlxuICogUmV0dXJucyB0aGUgY3VycmVudCBzeW5jIGNsaWVudC5cbiAqIEByZXR1cm5zIHs/fSBDdXJyZW50IHN5bmMgY2xpZW50LlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3VycmVudFN5bmNDbGllbnQoKSB7XG4gIGlmICghY3VycmVudENsaWVudCkgdGhyb3cgbmV3IEVycm9yKFwiTm8gc3luYyBjbGllbnQgY29uZmlndXJlZCAtIGNyZWF0ZSBhIFN5bmNDbGllbnQgYW5kIGNhbGwgc2V0Q3VycmVudCgpIG9uIGl0IGZpcnN0XCIpXG5cbiAgcmV0dXJuIGN1cnJlbnRDbGllbnRcbn1cbiJdfQ==

package/build/src/sync/sync-client-types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Client-declared sync scope serialized from a model query.
+ */
+export type SerializedSyncScope = {
+    /**
+     * - Plain attribute conditions from the query.
+     */
+    conditions: Record<string, unknown>;
+    /**
+     * - Resource/model name the scope was declared for.
+     */
+    resourceType: string;
+};
+/**
+ * Declarative per-resource sync policy.
+ */
+export type SyncClientResourceConfig = {
+    /**
+     * - Local model class for this resource.
+     */
+    modelClass: unknown;
+    /**
+     * - Pull-apply attribute mapper. Required for resources that receive pulled changes.
+     */
+    attributes?: ((args: {
+        data: Record<string, unknown>;
+        record: unknown;
+        sync: import("./sync-api-client-types.js").SyncChangeEnvelope;
+    }) => Promise<Record<string, unknown>> | Record<string, unknown>) | undefined;
+    /**
+     * - Custom pull-apply record resolver.
+     */
+    findRecord?: import("./sync-api-client-types.js").SyncResourceConfig["findRecord"];
+    /**
+     * - Custom pull-apply delete resolver.
+     */
+    findRecordForDelete?: import("./sync-api-client-types.js").SyncResourceConfig["findRecordForDelete"];
+    /**
+     * - Post-apply hook.
+     */
+    afterApply?: import("./sync-api-client-types.js").SyncResourceConfig["afterApply"];
+    /**
+     * - Attributes coerced through sync boolean parsing when queueing.
+     */
+    booleanAttributes?: string[] | undefined;
+    /**
+     * - Attributes stripped from queued payloads.
+     */
+    localOnlyAttributes?: string[] | undefined;
+    /**
+     * - Maps a mutation operation to a sync type. Defaults to the operation name with destroy mapped to "delete".
+     */
+    syncType?: ((args: {
+        operation: "create" | "update" | "destroy";
+        record: unknown;
+    }) => string) | undefined;
+    /**
+     * - Custom queued-payload builder for tracked mutations.
+     */
+    trackedData?: ((args: {
+        operation: "create" | "update" | "destroy";
+        record: unknown;
+    }) => Record<string, unknown>) | undefined;
+    /**
+     * - Enables automatic mutation tracking through model lifecycle callbacks.
+     */
+    track?: boolean | {
+        operations: Array<"create" | "update" | "destroy">;
+    } | undefined;
+};
+/**
+ * Declarative sync client configuration.
+ */
+export type SyncClientConfig = {
+    /**
+     * - Resolves the auth token sent with sync requests.
+     */
+    authenticationToken: () => string | Promise<string>;
+    /**
+     * - Max syncs per request.
+     */
+    batchSize?: number | undefined;
+    /**
+     * - Configuration owning the scope-store database. Defaults to the current configuration.
+     */
+    configuration?: import("../configuration.js").default | undefined;
+    /**
+     * - Connectivity gate for pulls and replays. Defaults to always online.
+     */
+    isOnline?: (() => boolean | Promise<boolean>) | undefined;
+    /**
+     * - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.
+     */
+    legacyCursor?: ((args: {
+        scope: SerializedSyncScope;
+    }) => string | null | Promise<string | null>) | undefined;
+    /**
+     * - Reports background replay/pull failures. Defaults to rethrowing.
+     */
+    onError?: ((error: Error) => void) | undefined;
+    /**
+     * - Posts one changes request.
+     */
+    postChanges: (payload: import("./sync-api-client-types.js").SyncChangesRequest & {
+        scope: SerializedSyncScope;
+    }) => Promise<import("./sync-api-client-types.js").SyncChangesResponse>;
+    /**
+     * - Posts one replay request.
+     */
+    postReplay: (payload: {
+        authenticationToken: string;
+        syncs: Array<Record<string, unknown>>;
+    }) => Promise<import("./sync-api-client-types.js").SyncReplayResponse>;
+    /**
+     * - Declarative resource policies keyed by resource/model name.
+     */
+    resources: Record<string, SyncClientResourceConfig>;
+    /**
+     * - Scope store override.
+     */
+    scopeStore?: import("./sync-scope-store.js").default | undefined;
+    /**
+     * - Local pending-sync model class.
+     */
+    syncModel: unknown;
+};
+//# sourceMappingURL=sync-client-types.d.ts.map

package/build/src/sync/sync-client-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-client-types.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":";;;;;;;gBAKc,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;;;;;;;;gBAMN,OAAC;;;;;;;;;;;;iBAED,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;0BACrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,qBAAqB,CAAC;;;;iBAC9E,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;;;;;;;;;uBAG9D;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM;;;;0BAClE;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;;oBAC7D,KAAK,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;;;;;;;;;;yBAM7D,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;;;;;;;;;;;;sBAGxB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;;;;2BACzB;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;;;;uBACtE,KAAK,KAAK,IAAI;;;;iBACtB,CAAC,OAAO,EAAE,OAAO,4BAA4B,EAAE,kBAAkB,GAAG;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,CAAC;;;;gBACtK,CAAC,OAAO,EAAE;QAAC,mBAAmB,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,4BAA4B,EAAE,kBAAkB,CAAC;;;;eAC7I,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC;;;;;;;;eAExC,OAAC"}

package/build/src/sync/sync-client-types.js

@@ -0,0 +1,3 @@
+// @ts-check
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/sync/sync-client.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Declares a sync scope on the current sync client.
+ * @param {import("../database/query/model-class-query.js").default<?>} query - Query declaring the sync scope.
+ * @returns {Promise<{scope: import("./sync-client-types.js").SerializedSyncScope, pulled: import("./sync-api-client-types.js").SyncChangesResult | null}>} Declared scope and pull result.
+ */
+export function sync(query: import("../database/query/model-class-query.js").default<unknown>): Promise<{
+    scope: import("./sync-client-types.js").SerializedSyncScope;
+    pulled: import("./sync-api-client-types.js").SyncChangesResult | null;
+}>;
+/**
+ * Declarative client-side sync driver.
+ *
+ * Apps configure resources, transport, auth, and connectivity once; Velocious
+ * owns scope persistence, per-scope cursors, pull paging/apply, local queueing,
+ * and online-gated replay. Declare sync interest from queries:
+ *
+ *     const syncClient = new SyncClient({...})
+ *     syncClient.setCurrent()
+ *     await syncClient.sync(Event.where({partnerId}))
+ */
+export default class SyncClient {
+    /**
+     * Returns the app's current sync client.
+     * @returns {SyncClient} Current sync client.
+     */
+    static current(): SyncClient;
+    /**
+     * Creates a declarative sync client.
+     * @param {import("./sync-client-types.js").SyncClientConfig} config - Sync client configuration.
+     */
+    constructor(config: import("./sync-client-types.js").SyncClientConfig);
+    config: import("./sync-client-types.js").SyncClientConfig;
+    _clientNumber: number;
+    /** @type {import("./sync-scope-store.js").default | null} */
+    _scopeStore: import("./sync-scope-store.js").default | null;
+    /** @type {Promise<void> | null} */
+    _scheduledReplay: Promise<void> | null;
+    /** @type {Record<string, import("./sync-api-client-types.js").SyncResourceConfig> | null} */
+    _pullResourceConfigs: Record<string, import("./sync-api-client-types.js").SyncResourceConfig> | null;
+    /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: "afterCreate" | "afterUpdate" | "afterDestroy", modelClass: ?}>} */
+    _trackedCallbacks: Array<{
+        callback: (record: unknown) => Promise<void>;
+        callbackName: "afterCreate" | "afterUpdate" | "afterDestroy";
+        modelClass: unknown;
+    }>;
+    /** @type {WeakSet<object>} */
+    _remoteApplyRecords: WeakSet<object>;
+    _started: boolean;
+    /**
+     * Registers automatic mutation tracking for every resource with `track` enabled:
+     * local model creates/updates/destroys queue pending sync rows and schedule an
+     * immediate replay attempt, without app-side queue calls.
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * Unregisters all tracking callbacks (tests, sign-out, hot reload).
+     * @returns {void}
+     */
+    stop(): void;
+    /**
+     * Resolves and validates the tracked operations for a resource config.
+     * @param {{resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig, resourceType: string}} args - Resource config and name.
+     * @returns {Array<"create" | "update" | "destroy">} Tracked operations.
+     */
+    trackedOperations({ resourceConfig, resourceType }: {
+        resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig;
+        resourceType: string;
+    }): Array<"create" | "update" | "destroy">;
+    /**
+     * Builds the lifecycle callback queueing one tracked mutation.
+     * @param {{operation: "create" | "update" | "destroy", resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig}} args - Operation and resource config.
+     * @returns {(record: ?) => Promise<void>} Lifecycle callback.
+     */
+    trackedMutationCallback({ operation, resourceConfig }: {
+        operation: "create" | "update" | "destroy";
+        resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig;
+    }): (record: unknown) => Promise<void>;
+    /**
+     * Whether a record is currently being written by pull-apply (echo suppression).
+     * @param {?} record - Local model record.
+     * @returns {boolean} Whether the record write originates from a remote change.
+     */
+    isRemoteApply(record: unknown): boolean;
+    /**
+     * Registers this client as the app's current sync client.
+     * @returns {void}
+     */
+    setCurrent(): void;
+    /**
+     * Declares (or re-activates) a sync scope from a model query and pulls it when online.
+     * @param {import("../database/query/model-class-query.js").default<?>} query - Query declaring the sync scope.
+     * @returns {Promise<{scope: import("./sync-client-types.js").SerializedSyncScope, pulled: import("./sync-api-client-types.js").SyncChangesResult | null}>} Declared scope and pull result (null while offline).
+     */
+    sync(query: import("../database/query/model-class-query.js").default<unknown>): Promise<{
+        scope: import("./sync-client-types.js").SerializedSyncScope;
+        pulled: import("./sync-api-client-types.js").SyncChangesResult | null;
+    }>;
+    /**
+     * Deactivates the sync scope declared by a model query.
+     * @param {import("../database/query/model-class-query.js").default<?>} query - Query whose scope should stop syncing.
+     * @returns {Promise<void>}
+     */
+    unsync(query: import("../database/query/model-class-query.js").default<unknown>): Promise<void>;
+    /**
+     * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).
+     * @returns {Promise<import("./sync-api-client-types.js").SyncChangesResult | null>} Combined pull result, or null while offline.
+     */
+    pull(): Promise<import("./sync-api-client-types.js").SyncChangesResult | null>;
+    /**
+     * Queues a local model change as a pending sync row and schedules an immediate
+     * replay attempt (kept pending while offline or when the backend rejects it).
+     * @param {{resource: ?, data?: Record<string, ?>, syncType?: string}} args - Queue args.
+     * @returns {Promise<?>} Pending local sync row.
+     */
+    queue({ data, resource, syncType }: {
+        resource: unknown;
+        data?: Record<string, unknown>;
+        syncType?: string;
+    }): Promise<unknown>;
+    /**
+     * Drains pending local sync rows to the backend (single-flighted, online-gated).
+     * Rows are only marked successful after the backend acknowledges them.
+     * @returns {Promise<void>}
+     */
+    replayPending(): Promise<void>;
+    /**
+     * Schedules a background replay attempt without blocking the caller.
+     * Failures go to config.onError (or rethrow when none is configured).
+     * @returns {void}
+     */
+    scheduleReplay(): void;
+    /**
+     * Awaits the last scheduled background replay (useful in tests and shutdown flows).
+     * @returns {Promise<void>}
+     */
+    waitForScheduledReplay(): Promise<void>;
+    /**
+     * Reports a background sync failure.
+     * @param {Error} error - Background failure.
+     * @returns {void}
+     */
+    reportError(error: Error): void;
+    /**
+     * Resolves connectivity through the configured gate.
+     * @returns {Promise<boolean>} Whether the backend is considered reachable.
+     */
+    isOnline(): Promise<boolean>;
+    /**
+     * Returns the scope store backing declared scopes and cursors.
+     * @returns {import("./sync-scope-store.js").default} Scope store.
+     */
+    scopeStore(): import("./sync-scope-store.js").default;
+    /**
+     * Resolves the declared resource config for a local record.
+     * @param {?} resource - Local model record.
+     * @returns {import("./sync-client-types.js").SyncClientResourceConfig} Declared resource config.
+     */
+    resourceConfigFor(resource: unknown): import("./sync-client-types.js").SyncClientResourceConfig;
+    /**
+     * Resolves the sync type for a mutation through the resource config.
+     * @param {{operation: "create" | "update" | "destroy", record: ?, resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig}} args - Mutation args.
+     * @returns {string} Sync type.
+     */
+    defaultSyncType({ operation, record, resourceConfig }: {
+        operation: "create" | "update" | "destroy";
+        record: unknown;
+        resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig;
+    }): string;
+    /**
+     * Derives the pull-apply resource configs from the declared resources.
+     * @returns {Record<string, import("./sync-api-client-types.js").SyncResourceConfig>} Pull-apply resource configs.
+     */
+    pullResourceConfigs(): Record<string, import("./sync-api-client-types.js").SyncResourceConfig>;
+}
+//# sourceMappingURL=sync-client.d.ts.map

package/build/src/sync/sync-client.d.ts.map

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