velocious 1.0.474 → 1.0.476

package/build/src/routes/hooks/frontend-model-command-route-hook.js

@@ -13,6 +13,20 @@ const FRONTEND_MODEL_CONTROLLER_PATH = new URL("../../frontend-model-controller.
  */
 export default async function frontendModelCommandRouteHook({ configuration, currentPath, hasMatchingCustomRoute }) {
     const normalizedCurrentPath = normalizePath(currentPath);
+    if (normalizedCurrentPath === "/frontend-models/sync/bootstrap") {
+        return {
+            action: "frontend-sync-bootstrap",
+            controller: "velocious/api",
+            controllerPath: FRONTEND_MODEL_CONTROLLER_PATH
+        };
+    }
+    if (normalizedCurrentPath === "/frontend-models/sync/replay") {
+        return {
+            action: "frontend-sync-replay",
+            controller: "velocious/api",
+            controllerPath: FRONTEND_MODEL_CONTROLLER_PATH
+        };
+    }
     if (normalizedCurrentPath === SHARED_FRONTEND_MODEL_API_PATH) {
         return {
             action: "frontend-api",
@@ -84,4 +98,4 @@ function normalizePath(path) {
     }
     return withLeadingSlash;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-model-command-route-hook.js","sourceRoot":"","sources":["../../../../src/routes/hooks/frontend-model-command-route-hook.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {frontendModelResourcesWithBuiltInsForBackendProject} from \"../../frontend-models/built-in-resources.js\"\nimport {frontendModelActionForCommand, frontendModelCustomCommandForPath, frontendModelResourcePath} from \"../../frontend-models/resource-definition.js\"\n\nconst SHARED_FRONTEND_MODEL_API_PATH = \"/frontend-models\"\nconst FRONTEND_MODEL_CONTROLLER_PATH = new URL(\"../../frontend-model-controller.js\", import.meta.url).href\n\n/**\n * Runs frontend model command route hook.\n * @param {object} args - Hook args.\n * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n * @param {string} args.currentPath - Request path without query.\n * @param {boolean} [args.hasMatchingCustomRoute] - Set when the request path matches an explicit custom route.\n * @returns {Promise<import(\"../../configuration-types.js\").RouteResolverHookResult | null>} - Route override or null.\n */\nexport default async function frontendModelCommandRouteHook({configuration, currentPath, hasMatchingCustomRoute}) {\n  const normalizedCurrentPath = normalizePath(currentPath)\n\n  if (normalizedCurrentPath === SHARED_FRONTEND_MODEL_API_PATH) {\n    return {\n      action: \"frontend-api\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  // Don't intercept paths that match explicitly defined custom routes\n  if (hasMatchingCustomRoute) return null\n\n  const backendProjects = configuration.getBackendProjects()\n  const customCommandMatch = frontendModelCustomCommandForPath({\n    backendProjects,\n    currentPath: normalizedCurrentPath\n  })\n\n  if (customCommandMatch) {\n    /**\n     * Params.\n     * @type {Record<string, ?>} */\n    const params = {\n      frontendModelCustomCommandMethodName: customCommandMatch.methodName,\n      frontendModelCustomCommandScope: customCommandMatch.scope,\n      model: customCommandMatch.modelName\n    }\n\n    if (customCommandMatch.memberId) {\n      params.id = customCommandMatch.memberId\n    }\n\n    return {\n      action: \"frontend-custom-command\",\n      controller: customCommandMatch.resourcePath.replace(/^\\/+/, \"\"),\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH,\n      params\n    }\n  }\n\n  for (const backendProject of backendProjects) {\n    const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)\n\n    for (const modelName in resources) {\n      const resourceDefinition = resources[modelName]\n      const resourcePath = frontendModelResourcePath(modelName, resourceDefinition)\n      const normalizedResourcePath = normalizePath(resourcePath)\n      const expectedPrefix = `${normalizedResourcePath}/`\n\n      if (!normalizedCurrentPath.startsWith(expectedPrefix)) continue\n\n      const commandName = normalizedCurrentPath.slice(expectedPrefix.length)\n      if (commandName.includes(\"/\")) continue\n\n      const action = frontendModelActionForCommand({commandName, modelName, resourceDefinition})\n      if (!action) continue\n      const controller = normalizedResourcePath.replace(/^\\/+/, \"\")\n\n      return {\n        action: `frontend-${action}`,\n        controller,\n        controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n      }\n    }\n  }\n\n  return null\n}\n\n/**\n * Runs normalize path.\n * @param {string} path - Path value.\n * @returns {string} - Normalized path with leading slash and no trailing slash.\n */\nfunction normalizePath(path) {\n  const withLeadingSlash = path.startsWith(\"/\") ? path : `/${path}`\n\n  if (withLeadingSlash.length > 1) {\n    return withLeadingSlash.replace(/\\/+$/, \"\")\n  }\n\n  return withLeadingSlash\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-model-command-route-hook.js","sourceRoot":"","sources":["../../../../src/routes/hooks/frontend-model-command-route-hook.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {frontendModelResourcesWithBuiltInsForBackendProject} from \"../../frontend-models/built-in-resources.js\"\nimport {frontendModelActionForCommand, frontendModelCustomCommandForPath, frontendModelResourcePath} from \"../../frontend-models/resource-definition.js\"\n\nconst SHARED_FRONTEND_MODEL_API_PATH = \"/frontend-models\"\nconst FRONTEND_MODEL_CONTROLLER_PATH = new URL(\"../../frontend-model-controller.js\", import.meta.url).href\n\n/**\n * Runs frontend model command route hook.\n * @param {object} args - Hook args.\n * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n * @param {string} args.currentPath - Request path without query.\n * @param {boolean} [args.hasMatchingCustomRoute] - Set when the request path matches an explicit custom route.\n * @returns {Promise<import(\"../../configuration-types.js\").RouteResolverHookResult | null>} - Route override or null.\n */\nexport default async function frontendModelCommandRouteHook({configuration, currentPath, hasMatchingCustomRoute}) {\n  const normalizedCurrentPath = normalizePath(currentPath)\n\n  if (normalizedCurrentPath === \"/frontend-models/sync/bootstrap\") {\n    return {\n      action: \"frontend-sync-bootstrap\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if (normalizedCurrentPath === \"/frontend-models/sync/replay\") {\n    return {\n      action: \"frontend-sync-replay\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if (normalizedCurrentPath === SHARED_FRONTEND_MODEL_API_PATH) {\n    return {\n      action: \"frontend-api\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  // Don't intercept paths that match explicitly defined custom routes\n  if (hasMatchingCustomRoute) return null\n\n  const backendProjects = configuration.getBackendProjects()\n  const customCommandMatch = frontendModelCustomCommandForPath({\n    backendProjects,\n    currentPath: normalizedCurrentPath\n  })\n\n  if (customCommandMatch) {\n    /**\n     * Params.\n     * @type {Record<string, ?>} */\n    const params = {\n      frontendModelCustomCommandMethodName: customCommandMatch.methodName,\n      frontendModelCustomCommandScope: customCommandMatch.scope,\n      model: customCommandMatch.modelName\n    }\n\n    if (customCommandMatch.memberId) {\n      params.id = customCommandMatch.memberId\n    }\n\n    return {\n      action: \"frontend-custom-command\",\n      controller: customCommandMatch.resourcePath.replace(/^\\/+/, \"\"),\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH,\n      params\n    }\n  }\n\n  for (const backendProject of backendProjects) {\n    const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)\n\n    for (const modelName in resources) {\n      const resourceDefinition = resources[modelName]\n      const resourcePath = frontendModelResourcePath(modelName, resourceDefinition)\n      const normalizedResourcePath = normalizePath(resourcePath)\n      const expectedPrefix = `${normalizedResourcePath}/`\n\n      if (!normalizedCurrentPath.startsWith(expectedPrefix)) continue\n\n      const commandName = normalizedCurrentPath.slice(expectedPrefix.length)\n      if (commandName.includes(\"/\")) continue\n\n      const action = frontendModelActionForCommand({commandName, modelName, resourceDefinition})\n      if (!action) continue\n      const controller = normalizedResourcePath.replace(/^\\/+/, \"\")\n\n      return {\n        action: `frontend-${action}`,\n        controller,\n        controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n      }\n    }\n  }\n\n  return null\n}\n\n/**\n * Runs normalize path.\n * @param {string} path - Path value.\n * @returns {string} - Normalized path with leading slash and no trailing slash.\n */\nfunction normalizePath(path) {\n  const withLeadingSlash = path.startsWith(\"/\") ? path : `/${path}`\n\n  if (withLeadingSlash.length > 1) {\n    return withLeadingSlash.replace(/\\/+$/, \"\")\n  }\n\n  return withLeadingSlash\n}\n"]}

package/build/src/sync/device-identity.d.ts

@@ -0,0 +1,240 @@
+/**
+ * JSON Web Key used by the sync signing helpers.
+ * @typedef {JsonWebKey} SyncJsonWebKey
+ */
+/**
+ * Backend-signed device certificate payload.
+ * @typedef {object} DeviceCertificatePayload
+ * @property {string} actorDeviceId - Device id allowed to sign mutations.
+ * @property {string} actorUserId - User id represented by the device.
+ * @property {string} certificateId - Certificate id.
+ * @property {SyncJsonWebKey} devicePublicKey - Device public key peers/backends use to verify mutations.
+ * @property {string} expiresAt - ISO timestamp after which the certificate is invalid.
+ * @property {string} issuedAt - ISO timestamp when the backend issued the certificate.
+ */
+/**
+ * Backend-signed device certificate envelope.
+ * @typedef {object} DeviceCertificate
+ * @property {"ECDSA-P256-SHA256"} algorithm - Signature algorithm.
+ * @property {DeviceCertificatePayload} certificate - Certificate payload.
+ * @property {string} signature - Backend signature over the certificate payload.
+ */
+/**
+ * Sync mutation payload signed by a device.
+ * @typedef {object} SyncMutation
+ * @property {string} actorDeviceId - Device that signed the mutation.
+ * @property {string} actorUserId - User represented by the signing device.
+ * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} [attributes] - Model attributes for CRUD mutations.
+ * @property {string | number | null} [baseVersion] - Base server/client version.
+ * @property {string} clientMutationId - Device-local idempotency id.
+ * @property {string} [command] - Domain command name for command mutations.
+ * @property {string} model - Sync model/resource name.
+ * @property {string} occurredAt - ISO timestamp when the mutation occurred.
+ * @property {string} offlineGrantId - Offline grant id authorizing the mutation.
+ * @property {string} operation - CRUD operation or command operation.
+ * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} [payload] - Domain command payload.
+ * @property {string} policyHash - Sync policy hash the mutation was checked against.
+ */
+/**
+ * Device-signed mutation envelope.
+ * @typedef {object} SignedSyncMutation
+ * @property {"ECDSA-P256-SHA256"} algorithm - Signature algorithm.
+ * @property {DeviceCertificate} deviceCertificate - Backend-signed device certificate.
+ * @property {SyncMutation} mutation - Mutation payload.
+ * @property {string} signature - Device signature over the mutation envelope.
+ */
+/**
+ * Generates an ECDSA P-256 keypair exported as JWKs.
+ * @returns {Promise<{privateKey: SyncJsonWebKey, publicKey: SyncJsonWebKey}>} - Exported keypair.
+ */
+export function generateSyncSigningKeyPair(): Promise<{
+    privateKey: SyncJsonWebKey;
+    publicKey: SyncJsonWebKey;
+}>;
+/**
+ * Creates a backend-signed device certificate.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.backendPrivateKey - Backend private signing key.
+ * @param {DeviceCertificatePayload} args.certificate - Certificate payload.
+ * @returns {Promise<DeviceCertificate>} - Signed certificate.
+ */
+export function createDeviceCertificate({ backendPrivateKey, certificate }: {
+    backendPrivateKey: SyncJsonWebKey;
+    certificate: DeviceCertificatePayload;
+}): Promise<DeviceCertificate>;
+/**
+ * Verifies a backend-signed device certificate.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.backendPublicKey - Backend public key.
+ * @param {DeviceCertificate} args.certificate - Signed certificate.
+ * @param {Date} [args.now] - Verification time. Defaults to current time.
+ * @returns {Promise<DeviceCertificatePayload>} - Verified certificate payload.
+ */
+export function verifyDeviceCertificate({ backendPublicKey, certificate, now }: {
+    backendPublicKey: SyncJsonWebKey;
+    certificate: DeviceCertificate;
+    now?: Date | undefined;
+}): Promise<DeviceCertificatePayload>;
+/**
+ * Creates a device-signed mutation envelope.
+ * @param {object} args - Arguments.
+ * @param {DeviceCertificate} args.deviceCertificate - Backend-signed device certificate.
+ * @param {SyncJsonWebKey} args.devicePrivateKey - Device private signing key.
+ * @param {SyncMutation} args.mutation - Mutation payload.
+ * @returns {Promise<SignedSyncMutation>} - Signed mutation.
+ */
+export function createSignedMutation({ deviceCertificate, devicePrivateKey, mutation }: {
+    deviceCertificate: DeviceCertificate;
+    devicePrivateKey: SyncJsonWebKey;
+    mutation: SyncMutation;
+}): Promise<SignedSyncMutation>;
+/**
+ * Verifies a signed sync mutation and its device certificate.
+ * @param {object} args - Arguments.
+ * @param {SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify the device certificate.
+ * @param {Date} [args.now] - Verification time. Defaults to current time.
+ * @param {SignedSyncMutation} args.signedMutation - Signed mutation envelope.
+ * @returns {Promise<SyncMutation>} - Verified mutation payload.
+ */
+export function verifySignedMutation({ backendPublicKey, now, signedMutation }: {
+    backendPublicKey: SyncJsonWebKey;
+    now?: Date | undefined;
+    signedMutation: SignedSyncMutation;
+}): Promise<SyncMutation>;
+/**
+ * Returns the replay/idempotency key for a signed mutation.
+ * @param {{mutation: {actorDeviceId?: unknown, actorUserId?: unknown, clientMutationId?: unknown}}} signedMutation - Signed mutation-like object.
+ * @returns {string} - Idempotency key.
+ */
+export function mutationIdempotencyKey(signedMutation: {
+    mutation: {
+        actorDeviceId?: unknown;
+        actorUserId?: unknown;
+        clientMutationId?: unknown;
+    };
+}): string;
+/**
+ * JSON Web Key used by the sync signing helpers.
+ */
+export type SyncJsonWebKey = JsonWebKey;
+/**
+ * Backend-signed device certificate payload.
+ */
+export type DeviceCertificatePayload = {
+    /**
+     * - Device id allowed to sign mutations.
+     */
+    actorDeviceId: string;
+    /**
+     * - User id represented by the device.
+     */
+    actorUserId: string;
+    /**
+     * - Certificate id.
+     */
+    certificateId: string;
+    /**
+     * - Device public key peers/backends use to verify mutations.
+     */
+    devicePublicKey: SyncJsonWebKey;
+    /**
+     * - ISO timestamp after which the certificate is invalid.
+     */
+    expiresAt: string;
+    /**
+     * - ISO timestamp when the backend issued the certificate.
+     */
+    issuedAt: string;
+};
+/**
+ * Backend-signed device certificate envelope.
+ */
+export type DeviceCertificate = {
+    /**
+     * - Signature algorithm.
+     */
+    algorithm: "ECDSA-P256-SHA256";
+    /**
+     * - Certificate payload.
+     */
+    certificate: DeviceCertificatePayload;
+    /**
+     * - Backend signature over the certificate payload.
+     */
+    signature: string;
+};
+/**
+ * Sync mutation payload signed by a device.
+ */
+export type SyncMutation = {
+    /**
+     * - Device that signed the mutation.
+     */
+    actorDeviceId: string;
+    /**
+     * - User represented by the signing device.
+     */
+    actorUserId: string;
+    /**
+     * - Model attributes for CRUD mutations.
+     */
+    attributes?: Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue> | undefined;
+    /**
+     * - Base server/client version.
+     */
+    baseVersion?: string | number | null | undefined;
+    /**
+     * - Device-local idempotency id.
+     */
+    clientMutationId: string;
+    /**
+     * - Domain command name for command mutations.
+     */
+    command?: string | undefined;
+    /**
+     * - Sync model/resource name.
+     */
+    model: string;
+    /**
+     * - ISO timestamp when the mutation occurred.
+     */
+    occurredAt: string;
+    /**
+     * - Offline grant id authorizing the mutation.
+     */
+    offlineGrantId: string;
+    /**
+     * - CRUD operation or command operation.
+     */
+    operation: string;
+    /**
+     * - Domain command payload.
+     */
+    payload?: Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue> | undefined;
+    /**
+     * - Sync policy hash the mutation was checked against.
+     */
+    policyHash: string;
+};
+/**
+ * Device-signed mutation envelope.
+ */
+export type SignedSyncMutation = {
+    /**
+     * - Signature algorithm.
+     */
+    algorithm: "ECDSA-P256-SHA256";
+    /**
+     * - Backend-signed device certificate.
+     */
+    deviceCertificate: DeviceCertificate;
+    /**
+     * - Mutation payload.
+     */
+    mutation: SyncMutation;
+    /**
+     * - Device signature over the mutation envelope.
+     */
+    signature: string;
+};
+//# sourceMappingURL=device-identity.d.ts.map

package/build/src/sync/device-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-identity.d.ts","sourceRoot":"","sources":["../../../src/sync/device-identity.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;GAOG;AAEH;;;GAGG;AACH,8CAFa,OAAO,CAAC;IAAC,UAAU,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,cAAc,CAAA;CAAC,CAAC,CAa5E;AAED;;;;;;GAMG;AACH,4EAJG;IAA6B,iBAAiB,EAAtC,cAAc;IACiB,WAAW,EAA1C,wBAAwB;CAChC,GAAU,OAAO,CAAC,iBAAiB,CAAC,CAatC;AAED;;;;;;;GAOG;AACH,gFALG;IAA6B,gBAAgB,EAArC,cAAc;IACU,WAAW,EAAnC,iBAAiB;IACL,GAAG;CACvB,GAAU,OAAO,CAAC,wBAAwB,CAAC,CAc7C;AAED;;;;;;;GAOG;AACH,wFALG;IAAgC,iBAAiB,EAAzC,iBAAiB;IACI,gBAAgB,EAArC,cAAc;IACK,QAAQ,EAA3B,YAAY;CACpB,GAAU,OAAO,CAAC,kBAAkB,CAAC,CAoBvC;AAED;;;;;;;GAOG;AACH,gFALG;IAA6B,gBAAgB,EAArC,cAAc;IACF,GAAG;IACU,cAAc,EAAvC,kBAAkB;CAC1B,GAAU,OAAO,CAAC,YAAY,CAAC,CAwBjC;AAED;;;;GAIG;AACH,uDAHW;IAAC,QAAQ,EAAE;QAAC,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAC,CAAA;CAAC,GACtF,MAAM,CAUlB;;;;6BApLY,UAAU;;;;;;;;mBAMT,MAAM;;;;iBACN,MAAM;;;;mBACN,MAAM;;;;qBACN,cAAc;;;;eACd,MAAM;;;;cACN,MAAM;;;;;;;;;eAMN,mBAAmB;;;;iBACnB,wBAAwB;;;;eACxB,MAAM;;;;;;;;;mBAMN,MAAM;;;;iBACN,MAAM;;;;;;;;;;;;sBAGN,MAAM;;;;;;;;WAEN,MAAM;;;;gBACN,MAAM;;;;oBACN,MAAM;;;;eACN,MAAM;;;;;;;;gBAEN,MAAM;;;;;;;;;eAMN,mBAAmB;;;;uBACnB,iBAAiB;;;;cACjB,YAAY;;;;eACZ,MAAM"}