@raytio/core 11.6.0 → 11.8.0

package/README.md

@@ -145,6 +145,7 @@ If you wish to use `@raytio/core` directly, an example of configuring polyfills
 - [pemToBytes](#pemtobytes)
 - [repairDate](#repairdate)
 - [requiresLocalSecret](#requireslocalsecret)
+- [resolveSchemaExtensions](#resolveschemaextensions)
 - [setArgon2Module](#setargon2module)
 - [signData](#signdata)
 - [signText](#signtext)
@@ -2024,6 +2025,34 @@ true if LocalSecret is required
 
 ___
 
+### resolveSchemaExtensions
+
+▸ **resolveSchemaExtensions**(`schemas`): `WrappedSchema`[]
+
+Resolves schema extensions by deep-merging base schemas into extension schemas.
+
+When a schema has `extends_schema_name` set, the base schema is looked up
+from the already-fetched schemas and deep-merged with the extension.
+The extension wins on conflict.
+
+Design constraints:
+- Single-level only: a base schema must not itself be an extension
+- Same tenant only: enforced at DB level
+- `extends_schema_version`: if set, matches against `schema_version`;
+  if null, the base's `version_current` entry is used (already in the list)
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `schemas` | `WrappedSchema`[] |
+
+#### Returns
+
+`WrappedSchema`[]
+
+___
+
 ### setArgon2Module
 
 ▸ **setArgon2Module**(`module`): `void`

package/dist/schema/expandSchema/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./expandSchema";
+export * from "./resolveSchemaExtensions";
 export * from "./sortSchemaProperties";
 export * from "./constants";
 export { findSuitableLocale } from "./i18n";

package/dist/schema/expandSchema/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findSuitableLocale = void 0;
 __exportStar(require("./expandSchema"), exports);
+__exportStar(require("./resolveSchemaExtensions"), exports);
 __exportStar(require("./sortSchemaProperties"), exports);
 __exportStar(require("./constants"), exports);
 var i18n_1 = require("./i18n");

package/dist/schema/expandSchema/removePrivateFields.d.ts

@@ -1,6 +1,16 @@
 import type { Schema } from "@raytio/types";
 export declare const removePrivateFields: (schema: Schema) => {
     properties: Record<string, Omit<import("@raytio/types").SchemaField, "$id" | "allOf" | "$schema" | "definitions">>;
+    id: never;
+    start_date: string;
+    end_date: string;
+    active: boolean;
+    metadata: unknown;
+    row_version?: number;
+    resource_group?: string;
+    resource_name?: string;
+    resource_url?: string;
+    tenant_id?: string;
     title: string;
     description: string;
     description_decorator?: "md";
@@ -159,8 +169,6 @@ export declare const removePrivateFields: (schema: Schema) => {
     verified_fields?: (string | import("@raytio/types").ConditionallyRequired)[];
     required?: (string | import("@raytio/types").ConditionallyRequired)[];
     wasExpandedByClient?: boolean;
-    start_date?: string;
-    end_date?: string;
     database?: {
         table?: string;
         primary_key: string;

package/dist/schema/expandSchema/resolveSchemaExtensions.d.ts

@@ -0,0 +1,15 @@
+import type { WrappedSchema } from "@raytio/types";
+/**
+ * Resolves schema extensions by deep-merging base schemas into extension schemas.
+ *
+ * When a schema has `extends_schema_name` set, the base schema is looked up
+ * from the already-fetched schemas and deep-merged with the extension.
+ * The extension wins on conflict.
+ *
+ * Design constraints:
+ * - Single-level only: a base schema must not itself be an extension
+ * - Same tenant only: enforced at DB level
+ * - `extends_schema_version`: if set, matches against `schema_version`;
+ *   if null, the base's `version_current` entry is used (already in the list)
+ */
+export declare function resolveSchemaExtensions(schemas: WrappedSchema[]): WrappedSchema[];

package/dist/schema/expandSchema/resolveSchemaExtensions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchemaExtensions = resolveSchemaExtensions;
+const ramda_1 = require("ramda");
+/**
+ * Resolves schema extensions by deep-merging base schemas into extension schemas.
+ *
+ * When a schema has `extends_schema_name` set, the base schema is looked up
+ * from the already-fetched schemas and deep-merged with the extension.
+ * The extension wins on conflict.
+ *
+ * Design constraints:
+ * - Single-level only: a base schema must not itself be an extension
+ * - Same tenant only: enforced at DB level
+ * - `extends_schema_version`: if set, matches against `schema_version`;
+ *   if null, the base's `version_current` entry is used (already in the list)
+ */
+function resolveSchemaExtensions(schemas) {
+    return schemas.map(schema => {
+        var _a, _b, _c, _d;
+        if (!schema.extends_schema_name) {
+            return schema;
+        }
+        const baseSchema = schemas.find(s => {
+            if (s.schema_name !== schema.extends_schema_name)
+                return false;
+            if (schema.extends_schema_version) {
+                return s.schema_version === schema.extends_schema_version;
+            }
+            return true; // version_current filtering already applied by the API query
+        });
+        if (!baseSchema) {
+            const versionNote = schema.extends_schema_version
+                ? ` (version ${schema.extends_schema_version})`
+                : "";
+            // eslint-disable-next-line no-console -- Warn when base schema is missing for extension
+            console.warn(`[resolveSchemaExtensions] Base schema "${schema.extends_schema_name}"${versionNote} not found for extension "${schema.schema_name}". Skipping merge.`);
+            return schema;
+        }
+        // Deep-merge the inner schema objects: base first, extension overrides
+        const mergedInnerSchema = (0, ramda_1.mergeDeepRight)(baseSchema.schema, schema.schema);
+        // Merge required arrays: union of base and extension required fields
+        const baseRequired = (_a = baseSchema.schema.required) !== null && _a !== void 0 ? _a : [];
+        const extRequired = (_b = schema.schema.required) !== null && _b !== void 0 ? _b : [];
+        const mergedRequired = [...new Set([...baseRequired, ...extRequired])];
+        // Merge verified_fields arrays: union of base and extension
+        const baseVerified = (_c = baseSchema.schema.verified_fields) !== null && _c !== void 0 ? _c : [];
+        const extVerified = (_d = schema.schema.verified_fields) !== null && _d !== void 0 ? _d : [];
+        const mergedVerified = [...new Set([...baseVerified, ...extVerified])];
+        return Object.assign(Object.assign({}, schema), { schema: Object.assign(Object.assign(Object.assign({}, mergedInnerSchema), (mergedRequired.length > 0 ? { required: mergedRequired } : {})), (mergedVerified.length > 0
+                ? { verified_fields: mergedVerified }
+                : {})) });
+    });
+}

package/dist/schema/expandSchema/unwrapSchema.d.ts

@@ -1,2 +1,2 @@
 import type { Schema, WrappedSchema } from "@raytio/types";
-export declare function unwrapSchema(wrapped: WrappedSchema): WrappedSchema["schema"] & Pick<WrappedSchema, "start_date" | "end_date" | "schema_type"> & Pick<Schema, "name" | "version">;
+export declare function unwrapSchema(wrapped: WrappedSchema): WrappedSchema["schema"] & Pick<WrappedSchema, "start_date" | "end_date" | "schema_type" | "active" | "resource_group" | "resource_name"> & Pick<Schema, "name" | "version" | "id" | "metadata">;

package/dist/schema/expandSchema/unwrapSchema.js

@@ -2,5 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unwrapSchema = unwrapSchema;
 function unwrapSchema(wrapped) {
-    return Object.assign(Object.assign({}, wrapped.schema), { name: wrapped.schema_name, start_date: wrapped.start_date, end_date: wrapped.end_date, version: wrapped.schema_version, schema_type: wrapped.schema_type });
+    return Object.assign(Object.assign({}, wrapped.schema), { name: wrapped.schema_name, start_date: wrapped.start_date, end_date: wrapped.end_date, version: wrapped.schema_version, schema_type: wrapped.schema_type, active: wrapped.active, resource_group: wrapped.resource_group, resource_name: wrapped.resource_name, 
+        // schemas are identified by `name`, not `id`; CommonFields-aligned but unused
+        id: undefined, metadata: undefined });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raytio/core",
-  "version": "11.6.0",
+  "version": "11.8.0",
   "license": "MIT",
   "main": "index",
   "types": "index",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@raytio/maxcryptor": "3.1.0",
-    "@raytio/types": "8.1.0",
+    "@raytio/types": "8.3.0",
     "openpgp": "^6.1.0",
     "ramda": "0.30.1"
   },