@takeshape/schema 11.88.2 → 11.88.4

package/dist/models/query.d.ts

@@ -1,9 +1,9 @@
 import type { ObjectSchema } from '../project-schema/latest.ts';
 import { type QueryEntry } from '../refs.ts';
-import type { IRuntimeSchema } from './types.ts';
+import type { ReferenceResolver } from './types.ts';
 export declare class Query {
     #private;
-    constructor(parent: IRuntimeSchema, entry: QueryEntry);
+    constructor(parent: ReferenceResolver, entry: QueryEntry);
     get ref(): string;
     get argsSchema(): ObjectSchema | undefined;
 }

package/dist/models/query.js

@@ -1,11 +1,11 @@
 import { serializePropertyRef } from "../refs.js";
 export class Query {
-    #parent;
+    #refResolver;
     #name;
     #query;
     #ref;
     constructor(parent, entry) {
-        this.#parent = parent;
+        this.#refResolver = parent;
         this.#name = entry.name;
         this.#query = entry.query;
         this.#ref = entry.ref;
@@ -19,7 +19,7 @@ export class Query {
             if (typeof args === 'object') {
                 return args;
             }
-            return this.#parent.getShape(args)?.getObjectSchema();
+            return this.#refResolver.getShape(args)?.getObjectSchema();
         }
         return undefined;
     }

package/dist/models/runtime-schema.d.ts

@@ -1,13 +1,13 @@
-import type { ProjectSchemaJSON, PropertySchema } from '../project-schema/index.ts';
+import type { ProjectSchemaJSON } from '../project-schema/index.ts';
 import type { ServiceLayers } from '../types/types.ts';
 import { Query } from './query.js';
 import { Shape } from './shape.js';
-import type { IRuntimeSchema } from './types.ts';
-export declare class RuntimeSchema implements IRuntimeSchema {
+export declare class RuntimeSchema {
     #private;
-    constructor(userSchema: ProjectSchemaJSON, layers: ServiceLayers);
-    get runtimeSchemaJson(): ProjectSchemaJSON;
-    getShape(rawShapeRef: string): Shape | undefined;
-    getQuery(rawQueryRef: string): Query | undefined;
-    dereferenceSchema(propertySchema: PropertySchema): PropertySchema;
+    private constructor();
+    static buildSchema(userSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema;
+    static fromJson(runtimeSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema;
+    getQuery(ref: string): Query | undefined;
+    getShape(ref: string): Shape | undefined;
+    get json(): ProjectSchemaJSON;
 }

package/dist/models/runtime-schema.js

@@ -3,33 +3,25 @@ import { buildRuntimeSchema } from "../runtime-schema.js";
 import { getShape } from "../util/shapes.js";
 import { Query } from './query.js';
 import { Shape } from './shape.js';
-export class RuntimeSchema {
-    #userSchema;
-    #runtimeSchema;
+class ProjectSchemaRefResolver {
+    #runtimeSchemaJson;
     #layers;
     #shapeCache;
     #queryCache;
-    constructor(userSchema, layers) {
-        this.#userSchema = userSchema;
+    constructor(runtimeSchema, layers) {
+        this.#runtimeSchemaJson = runtimeSchema;
         this.#layers = layers;
         this.#shapeCache = new Map();
         this.#queryCache = new Map();
     }
-    get runtimeSchemaJson() {
-        if (!this.#runtimeSchema) {
-            // biome-ignore lint/suspicious/noConsole: ignore
-            this.#runtimeSchema = buildRuntimeSchema(this.#userSchema, this.#layers, console.log);
-        }
-        return this.#runtimeSchema;
-    }
     getShape(rawShapeRef) {
-        const shapeRef = normalizeRefExpression(this.#userSchema, rawShapeRef);
+        const shapeRef = normalizeRefExpression(this.#runtimeSchemaJson, rawShapeRef);
         let shape = this.#shapeCache.get(shapeRef);
         if (!shape) {
-            const refItem = refExpressionToRefItem(this.runtimeSchemaJson, rawShapeRef);
+            const refItem = refExpressionToRefItem(this.#runtimeSchemaJson, rawShapeRef);
             if (refItem) {
                 const namespacedName = refItemToNamespacedShapeName(refItem);
-                const shapeJson = getShape(this.runtimeSchemaJson, namespacedName);
+                const shapeJson = getShape(this.#runtimeSchemaJson, namespacedName);
                 if (shapeJson) {
                     shape = new Shape(this, refItem, shapeJson);
                     this.#shapeCache.set(shapeRef, shape);
@@ -52,7 +44,7 @@ export class RuntimeSchema {
         const queryRef = normalizePropertyRef(rawQueryRef);
         let query = this.#queryCache.get(queryRef);
         if (!query) {
-            const queryEntry = getQuery(this.runtimeSchemaJson, queryRef);
+            const queryEntry = getQuery(this.#runtimeSchemaJson, queryRef);
             if (queryEntry) {
                 query = new Query(this, queryEntry);
                 this.#queryCache.set(queryRef, query);
@@ -74,6 +66,33 @@ export class RuntimeSchema {
         return query;
     }
     dereferenceSchema(propertySchema) {
-        return dereferenceSchema(this.runtimeSchemaJson, propertySchema);
+        return dereferenceSchema(this.#runtimeSchemaJson, propertySchema);
+    }
+}
+export class RuntimeSchema {
+    #runtimeSchemaJson;
+    #layers;
+    #refResolver;
+    constructor(runtimeSchema, layers) {
+        this.#runtimeSchemaJson = runtimeSchema;
+        this.#layers = layers;
+        this.#refResolver = new ProjectSchemaRefResolver(runtimeSchema, layers);
+    }
+    static buildSchema(userSchema, layers) {
+        // biome-ignore lint/suspicious/noConsole: ignore
+        const runtimeSchema = buildRuntimeSchema(userSchema, layers, console.log);
+        return new RuntimeSchema(runtimeSchema, layers);
+    }
+    static fromJson(runtimeSchema, layers) {
+        return new RuntimeSchema(runtimeSchema, layers);
+    }
+    getQuery(ref) {
+        return this.#refResolver.getQuery(ref);
+    }
+    getShape(ref) {
+        return this.#refResolver.getShape(ref);
+    }
+    get json() {
+        return this.#runtimeSchemaJson;
     }
 }

package/dist/models/shape.d.ts

@@ -1,9 +1,9 @@
 import type { ShapeJSON } from '../project-schema/latest.ts';
 import { type RefItem } from '../refs.ts';
-import type { IRuntimeSchema } from './types.ts';
+import type { ReferenceResolver } from './types.ts';
 export declare class Shape {
     #private;
-    constructor(parent: IRuntimeSchema, ref: RefItem, shape: ShapeJSON);
+    constructor(parent: ReferenceResolver, ref: RefItem, shape: ShapeJSON);
     get name(): string;
     get ref(): string;
     get refItem(): RefItem;

package/dist/models/shape.js

@@ -1,12 +1,12 @@
 import { refItemToAtRef } from "../refs.js";
 import { isObjectSchema } from "../types/utils.js";
 export class Shape {
-    #parent;
+    #refResolver;
     #ref;
     #shape;
     #dereferencedSchema;
     constructor(parent, ref, shape) {
-        this.#parent = parent;
+        this.#refResolver = parent;
         this.#ref = ref;
         this.#shape = shape;
     }
@@ -21,7 +21,7 @@ export class Shape {
     }
     getObjectSchema() {
         if (!this.#dereferencedSchema) {
-            this.#dereferencedSchema = this.#parent.dereferenceSchema(this.#shape.schema);
+            this.#dereferencedSchema = this.#refResolver.dereferenceSchema(this.#shape.schema);
         }
         if (isObjectSchema(this.#dereferencedSchema)) {
             return this.#dereferencedSchema;

package/dist/models/types.d.ts

@@ -1,7 +1,7 @@
 import type { Query } from '@/src/models/query.js';
 import type { Shape } from '@/src/models/shape.js';
 import type { PropertySchema } from '../project-schema/index.ts';
-export interface IRuntimeSchema {
+export interface ReferenceResolver {
     getShape(shapeRef: string): Shape | undefined;
     getQuery(queryRef: string): Query | undefined;
     dereferenceSchema(propertySchema: PropertySchema): PropertySchema;

package/dist/refs.d.ts

@@ -15,7 +15,8 @@ export type RefItem = {
     template?: string;
     isForeign: boolean;
     isValidService: boolean;
-} & Record<string, unknown>;
+    isInterfaceRef?: boolean;
+};
 /**
  * Adds a schema path, needed when visiting a whole schema to report errors.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/schema",
-  "version": "11.88.2",
+  "version": "11.88.4",
   "description": "TakeShape Schema",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -57,9 +57,9 @@
     "p-reduce": "^2.1.0",
     "semver": "^7.3.2",
     "tiny-invariant": "^1.2.0",
-    "@takeshape/errors": "11.88.2",
-    "@takeshape/json-schema": "11.88.2",
-    "@takeshape/util": "11.88.2"
+    "@takeshape/errors": "11.88.4",
+    "@takeshape/json-schema": "11.88.4",
+    "@takeshape/util": "11.88.4"
   },
   "devDependencies": {
     "@takeshape/json-schema-to-typescript": "^11.0.0",
@@ -76,7 +76,7 @@
     "json-schema-to-ts": "^3.1.1",
     "meow": "^9.0.0",
     "shortid": "^2.2.15",
-    "@takeshape/infra": "11.88.2"
+    "@takeshape/infra": "11.88.4"
   },
   "engines": {
     "node": ">=20"