@takeshape/schema 11.69.0 → 11.70.2

package/dist/content-schema-transform.js

@@ -57,7 +57,7 @@ export function findTransforms(pluginMap, schema, name, shape) {
 }
 export function getContentTransform({ transforms, accumulators, keyTransform = preferKey, sourceKeyTransform = preferSourceKey, passThrough = true, allowNullObjects = false, projectSchema }) {
     const nonDefaultLocales = getNonDefaultLocales(projectSchema);
-    const prepare = (schema, obj, name = '') => {
+    const prepare = (schema, obj, name = '', parent) => {
         const shapeName = getRefShapeName(projectSchema, schema);
         schema = dereferenceSchema(projectSchema, schema);
         if (accumulators) {
@@ -68,13 +68,13 @@ export function getContentTransform({ transforms, accumulators, keyTransform = p
         const shape = shapeName ? projectSchema.shapes[shapeName] : undefined;
         const transform = findTransforms(transforms, schema, name, shape);
         if (transform) {
-            const next = (value, schema, name) => prepare(schema, value, name);
-            return transform.process(obj, schema, name, shape, next);
+            const next = (value, schema, name, parent) => prepare(schema, value, name, parent);
+            return transform.process(obj, { ...schema, $parent: parent }, name, shape, next);
         }
         if (obj && isUnionSchema(schema)) {
             for (const { shapeId, propSchema } of enumerateOneOfKeys(projectSchema, schema.oneOf)) {
                 if (obj._shapeId === shapeId) {
-                    return prepare(propSchema, obj, name);
+                    return prepare(propSchema, obj, name, schema);
                 }
             }
         }
@@ -85,7 +85,7 @@ export function getContentTransform({ transforms, accumulators, keyTransform = p
                 const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema, obj));
                 const localizedSourceKeys = getLocalizedSourceKeys(sourceKeys, nonDefaultLocales);
                 for (const { key: sourceKey, locale } of localizedSourceKeys) {
-                    const value = prepare(fieldSchema, get(obj, sourceKey), name);
+                    const value = prepare(fieldSchema, get(obj, sourceKey), name, schema);
                     if (value !== undefined) {
                         assigned.add(sourceKey);
                         const transform = findTransforms(transforms, dereferenceSchema(projectSchema, fieldSchema), name);
@@ -106,10 +106,10 @@ export function getContentTransform({ transforms, accumulators, keyTransform = p
         if (isArraySchema(schema)) {
             const itemSchema = schema.items;
             if (Array.isArray(obj)) {
-                return obj.map((item) => prepare(itemSchema, item, name));
+                return obj.map((item) => prepare(itemSchema, item, name, schema));
             }
             if (obj === undefined) {
-                prepare(itemSchema, obj, name);
+                prepare(itemSchema, obj, name, parent);
             }
         }
         if (allowNullObjects && isObjectSchema(schema) && obj === null) {

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export * from './interfaces.ts';
 export * from './migration/index.ts';
 export type { ProjectSchemaUpdate } from './migration/types.ts';
 export * from './mocks.ts';
+export * from './models/runtime-schema.ts';
 export * from './patterns.ts';
 export * from './project-schema/index.ts';
 export * from './project-schema/migrate.ts';

package/dist/index.js

@@ -10,6 +10,7 @@ export * from "./get-is-leaf.js";
 export * from "./interfaces.js";
 export * from "./migration/index.js";
 export * from "./mocks.js";
+export * from "./models/runtime-schema.js";
 export * from "./patterns.js";
 export * from "./project-schema/index.js";
 export * from "./project-schema/migrate.js";

package/dist/models/__tests__/fixtures.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectSchemaJSON } from '../../project-schema/index.ts';
+import type { ServiceLayers } from '../../types/index.ts';
+export declare const rickLayers: ServiceLayers;
+export declare const rickSchema: ProjectSchemaJSON;
+export declare const expectedSupaArgsSchema: {
+    properties: {
+        a: {
+            type: string;
+        };
+        b: {
+            type: string;
+        };
+    };
+    type: string;
+};

package/dist/models/__tests__/fixtures.js

@@ -0,0 +1,56 @@
+import rickLayerJson from '@/examples/latest/layers/rick-and-morty-layer.json';
+import rickSchemaJson from '@/examples/latest/rick-and-morty-user-schema.json';
+import { createShape } from "../../schema-util.js";
+export const rickLayers = {
+    rick: {
+        id: 'rick',
+        schema: rickLayerJson,
+        status: 'ok'
+    }
+};
+export const rickSchema = {
+    ...rickSchemaJson,
+    queries: {
+        ...rickSchemaJson.queries,
+        shapeArgs: {
+            shape: 'JSON',
+            resolver: {
+                name: 'util:noop'
+            },
+            args: 'SupaArgs'
+        }
+    },
+    shapes: {
+        ...rickSchemaJson.shapes,
+        ArgsA: createShape('ArgsA', {
+            type: 'object',
+            properties: {
+                a: {
+                    type: 'boolean'
+                }
+            }
+        }),
+        ArgsB: createShape('ArgsB', {
+            type: 'object',
+            properties: {
+                b: {
+                    type: 'boolean'
+                }
+            }
+        }),
+        SupaArgs: createShape('SupaArgs', {
+            extends: [{ '@ref': 'local:ArgsA' }, { '@ref': 'local:ArgsB' }]
+        })
+    }
+};
+export const expectedSupaArgsSchema = {
+    properties: {
+        a: {
+            type: 'boolean'
+        },
+        b: {
+            type: 'boolean'
+        }
+    },
+    type: 'object'
+};

package/dist/models/__tests__/query.test.js

@@ -1,27 +1,19 @@
 import { describe, expect, test } from 'vitest';
-import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
-import { ProjectSchema } from "../project-schema.js";
-import { QueryModel } from "../query.js";
-const projectSchema = shopifySchemaJson;
-const projectSchemaModel = new ProjectSchema(projectSchema);
-describe('QueryModel', () => {
-    const queryType = 'query';
-    const queryName = 'getAssetList';
-    const rawQuery = projectSchema.queries[queryName];
-    const queryModel = new QueryModel(projectSchemaModel, queryType, queryName);
-    test('can create from query', () => {
-        expect(queryModel instanceof QueryModel).toEqual(true);
+import { RuntimeSchema } from "../runtime-schema.js";
+import { expectedSupaArgsSchema, rickLayers, rickSchema } from './fixtures.js';
+const runtimeSchema = new RuntimeSchema(rickSchema, rickLayers);
+describe('Query', () => {
+    test('ref', () => {
+        const ref = 'rick:Query.episodes';
+        const query = runtimeSchema.getQuery(ref);
+        expect(query?.ref).toBe(ref);
     });
-    test('can create from mutation', () => {
-        const queryModelFromMutation = new QueryModel(projectSchemaModel, 'mutation', 'updateAsset');
-        expect(queryModelFromMutation instanceof QueryModel).toEqual(true);
+    test('argsSchema - inline args', () => {
+        const argsSchema = runtimeSchema.getQuery('rick:Query.episodes')?.argsSchema;
+        expect(argsSchema?.type).toBe('object');
     });
-    test('basic accessors', () => {
-        expect(queryModel.queryType).toEqual(queryType);
-        expect(queryModel.name).toEqual(queryName);
-        expect(queryModel.json).toEqual(rawQuery);
-        expect(queryModel.description).toEqual(rawQuery.description);
-        expect(queryModel.resolver).toEqual(rawQuery.resolver);
-        expect(queryModel.returnShape).toEqual(rawQuery.shape);
+    test('argsSchema - shape args', () => {
+        const argsSchema = runtimeSchema.getQuery('shapeArgs')?.argsSchema;
+        expect(argsSchema).toEqual(expectedSupaArgsSchema);
     });
 });

package/dist/models/__tests__/runtime-schema.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'vitest';
+import { RuntimeSchema } from "../runtime-schema.js";
+import { rickLayers, rickSchema } from './fixtures.js';
+describe('RuntimeSchema', () => {
+    const runtimeSchema = new RuntimeSchema(rickSchema, rickLayers);
+    test('getShape - local', () => {
+        const ref = 'local:Asset';
+        const assetFromRef = runtimeSchema.getShape(ref);
+        const assetFromName = runtimeSchema.getShape('Asset');
+        expect(assetFromName?.ref).toBe(ref);
+        expect(assetFromName).toBe(assetFromRef);
+    });
+    test('getShape - overridden', () => {
+        const ref = 'rick:Character';
+        const shapeFromRef = runtimeSchema.getShape(ref);
+        const shapeFromName = runtimeSchema.getShape('Rick_Character');
+        expect(shapeFromRef?.ref).toBe(ref);
+        expect(shapeFromRef).toBe(shapeFromName);
+    });
+    test('getShape - remote', () => {
+        const ref = 'rick:FilterEpisode';
+        const shape = runtimeSchema.getShape(ref);
+        expect(shape?.ref).toBe(ref);
+    });
+    test('getQuery - local', () => {
+        const queryFromName = runtimeSchema.getQuery('getAssetList');
+        const queryFromRef = runtimeSchema.getQuery('Query.getAssetList');
+        expect(queryFromName).toBeTruthy();
+        expect(queryFromName).toEqual(queryFromRef);
+    });
+    test('getQuery - overridden', () => {
+        const ref = 'rick:Query.characters';
+        const queryFromName = runtimeSchema.getQuery(ref);
+        const queryFromRef = runtimeSchema.getQuery('Query.Rick_characters');
+        expect(queryFromName?.ref).toBe(ref);
+        expect(queryFromName).toEqual(queryFromRef);
+    });
+    test('getQuery - remote', () => {
+        const ref = 'rick:Query.episodes';
+        const query = runtimeSchema.getQuery(ref);
+        expect(query?.ref).toEqual(ref);
+    });
+});

package/dist/models/__tests__/shape.test.js

@@ -1,61 +1,24 @@
 import { describe, expect, test } from 'vitest';
-import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
-import { ProjectSchema } from "../project-schema.js";
-import { ShapeModel } from "../shape.js";
-const projectSchema = shopifySchemaJson;
-const projectSchemaModel = new ProjectSchema(projectSchema);
-describe('ShapeModel', () => {
-    const shapeRef = 'local:Asset';
-    const shapeRefItem = {
-        isForeign: false,
+import { expectedSupaArgsSchema, rickLayers, rickSchema } from '@/src/models/__tests__/fixtures.js';
+import { RuntimeSchema } from "../runtime-schema.js";
+import { Shape } from "../shape.js";
+const runtimeSchema = new RuntimeSchema(rickSchema, rickLayers);
+describe('Shape', () => {
+    const refItem = {
         serviceKey: 'local',
-        typeName: 'Asset',
-        isValidService: true
+        typeName: 'SupaArgs',
+        isForeign: false,
+        isValidService: true,
+        isLocal: true
     };
-    const rawShape = projectSchema.shapes.Asset;
-    const shapeModel = new ShapeModel(projectSchemaModel, shapeRef);
-    test('created using ref string', () => {
-        expect(shapeModel instanceof ShapeModel).toEqual(true);
-    });
-    test('invalid ref string', () => {
-        expect(() => new ShapeModel(projectSchemaModel, 'local:Bogus')).toThrowError('Error creating shape model: local:Bogus is not in project schema');
-    });
-    test('created using ref item', () => {
-        const shapeModelCreatedUsingRefItem = new ShapeModel(projectSchemaModel, {
-            isForeign: false,
-            serviceKey: 'local',
-            typeName: 'Asset',
-            isValidService: true
-        });
-        expect(shapeModelCreatedUsingRefItem instanceof ShapeModel).toEqual(true);
-    });
-    test('invalid ref item', () => {
-        expect(() => new ShapeModel(projectSchemaModel, {
-            isForeign: false,
-            serviceKey: 'local',
-            typeName: 'Bogus',
-            isValidService: true
-        })).toThrowError('Error creating shape model: ref item argument could not be resolved to a shape');
-    });
-    test('basic accessors', () => {
-        expect(shapeModel.json).toEqual(rawShape);
-        expect(shapeModel.id).toEqual(rawShape.id);
-        expect(shapeModel.name).toEqual(rawShape.name);
-        expect(shapeModel.title).toEqual(rawShape.title);
-        expect(shapeModel.description).toEqual(rawShape.description);
-        expect(shapeModel.schema).toEqual(rawShape.schema);
-        expect(shapeModel.schemaPropertyList.getValues().length).toEqual(21);
-        expect(shapeModel.schemaPropertyAccessor.getValue('uploadStatus').title).toEqual('Upload status');
-        expect(shapeModel.refString).toEqual(shapeRef);
-        expect(shapeModel.refItem).toEqual(shapeRefItem);
-        expect(shapeModel.serviceId).toEqual('local');
-        expect(shapeModel.modelType).toEqual('multiple');
-        expect(shapeModel.interfaces).toEqual(undefined);
+    const rawShape = rickSchema.shapes.SupaArgs;
+    const shape = new Shape(runtimeSchema, refItem, rawShape);
+    test('getters', () => {
+        expect(shape.name).toBe(rawShape.name);
+        expect(shape.ref).toBe('local:SupaArgs');
+        expect(shape.refItem).toBe(refItem);
     });
-    test('informational', () => {
-        expect(shapeModel.isModel).toEqual(true);
-        expect(shapeModel.isCached).toEqual(false);
-        expect(shapeModel.isAsset).toEqual(true);
-        expect(shapeModel.isInterfaceShape).toEqual(false);
+    test('getObjectSchema', () => {
+        expect(shape.getObjectSchema()).toEqual(expectedSupaArgsSchema);
     });
 });

package/dist/models/query.d.ts

@@ -1,17 +1,9 @@
-import type { QueryJSON } from '../project-schema/index.ts';
-import type { IProjectSchema } from './types.ts';
-/**
- * Create a model object representing a query or mutation.
- */
-export declare class QueryModel {
-    private readonly _queryType;
-    private readonly _queryName;
-    private readonly _rawQuery;
-    constructor(projectSchemaModel: IProjectSchema, _queryType: 'query' | 'mutation', _queryName: string);
-    get queryType(): "query" | "mutation";
-    get name(): string;
-    get json(): QueryJSON;
-    get description(): string | undefined;
-    get resolver(): import("../project-schema/latest.ts").Resolver;
-    get returnShape(): import("../project-schema/latest.ts").ReturnShape;
+import type { ObjectSchema } from '../project-schema/latest.ts';
+import { type QueryEntry } from '../refs.ts';
+import type { IRuntimeSchema } from './types.ts';
+export declare class Query {
+    #private;
+    constructor(parent: IRuntimeSchema, entry: QueryEntry);
+    get ref(): string;
+    get argsSchema(): ObjectSchema | undefined;
 }

package/dist/models/query.js

@@ -1,31 +1,26 @@
-/**
- * Create a model object representing a query or mutation.
- */
-export class QueryModel {
-    _queryType;
-    _queryName;
-    _rawQuery;
-    constructor(projectSchemaModel, _queryType, _queryName) {
-        this._queryType = _queryType;
-        this._queryName = _queryName;
-        this._rawQuery = projectSchemaModel.json[_queryType === 'query' ? 'queries' : 'mutations'][_queryName];
+import { serializePropertyRef } from "../refs.js";
+export class Query {
+    #parent;
+    #name;
+    #query;
+    #ref;
+    constructor(parent, entry) {
+        this.#parent = parent;
+        this.#name = entry.name;
+        this.#query = entry.query;
+        this.#ref = entry.ref;
     }
-    get queryType() {
-        return this._queryType;
+    get ref() {
+        return serializePropertyRef(this.#ref);
     }
-    get name() {
-        return this._queryName;
-    }
-    get json() {
-        return this._rawQuery;
-    }
-    get description() {
-        return this.json.description;
-    }
-    get resolver() {
-        return this.json.resolver;
-    }
-    get returnShape() {
-        return this.json.shape;
+    get argsSchema() {
+        const args = this.#query.args;
+        if (args) {
+            if (typeof args === 'object') {
+                return args;
+            }
+            return this.#parent.getShape(args)?.getObjectSchema();
+        }
+        return undefined;
     }
 }

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

@@ -0,0 +1,13 @@
+import type { ProjectSchemaJSON, PropertySchema } 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 {
+    #private;
+    constructor(userSchema: ProjectSchemaJSON, layers: ServiceLayers);
+    get runtimeSchemaJson(): ProjectSchemaJSON;
+    getShape(rawShapeRef: string): Shape | undefined;
+    getQuery(rawQueryRef: string): Query | undefined;
+    dereferenceSchema(propertySchema: PropertySchema): PropertySchema;
+}

package/dist/models/runtime-schema.js

@@ -0,0 +1,78 @@
+import { dereferenceSchema, getQuery, normalizePropertyRef, normalizeRefExpression, parsePropertyRef, refExpressionToRefItem, refItemToNamespacedShapeName } from "../refs.js";
+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;
+    #layers;
+    #shapeCache;
+    #queryCache;
+    constructor(userSchema, layers) {
+        this.#userSchema = userSchema;
+        this.#layers = layers;
+        this.#shapeCache = new Map();
+        this.#queryCache = new Map();
+    }
+    get runtimeSchemaJson() {
+        if (!this.#runtimeSchema) {
+            this.#runtimeSchema = buildRuntimeSchema(this.#userSchema, this.#layers, console.log);
+        }
+        return this.#runtimeSchema;
+    }
+    getShape(rawShapeRef) {
+        const shapeRef = normalizeRefExpression(this.#userSchema, rawShapeRef);
+        let shape = this.#shapeCache.get(shapeRef);
+        if (!shape) {
+            const refItem = refExpressionToRefItem(this.runtimeSchemaJson, rawShapeRef);
+            if (refItem) {
+                const namespacedName = refItemToNamespacedShapeName(refItem);
+                const shapeJson = getShape(this.runtimeSchemaJson, namespacedName);
+                if (shapeJson) {
+                    shape = new Shape(this, refItem, shapeJson);
+                    this.#shapeCache.set(shapeRef, shape);
+                }
+                else if (refItem.serviceKey !== 'local') {
+                    const layerSchema = this.#layers[refItem.serviceKey]?.schema;
+                    if (layerSchema) {
+                        const shapeJson = getShape(layerSchema, namespacedName);
+                        if (shapeJson) {
+                            shape = new Shape(this, refItem, shapeJson);
+                            this.#shapeCache.set(shapeRef, shape);
+                        }
+                    }
+                }
+            }
+        }
+        return shape;
+    }
+    getQuery(rawQueryRef) {
+        const queryRef = normalizePropertyRef(rawQueryRef);
+        let query = this.#queryCache.get(queryRef);
+        if (!query) {
+            const queryEntry = getQuery(this.runtimeSchemaJson, queryRef);
+            if (queryEntry) {
+                query = new Query(this, queryEntry);
+                this.#queryCache.set(queryRef, query);
+            }
+            else {
+                const parsedRef = parsePropertyRef(queryRef);
+                if (parsedRef && parsedRef.serviceId !== 'local') {
+                    const layerSchema = this.#layers[parsedRef.serviceId]?.schema;
+                    if (layerSchema) {
+                        const queryEntry = getQuery(layerSchema, parsedRef.propertyName);
+                        if (queryEntry) {
+                            query = new Query(this, { ...queryEntry, ref: parsedRef });
+                            this.#queryCache.set(queryRef, query);
+                        }
+                    }
+                }
+            }
+        }
+        return query;
+    }
+    dereferenceSchema(propertySchema) {
+        return dereferenceSchema(this.runtimeSchemaJson, propertySchema);
+    }
+}

package/dist/models/shape.d.ts

@@ -1,41 +1,11 @@
-import type { ShapeJSON } from '../project-schema/index.ts';
+import type { ShapeJSON } from '../project-schema/latest.ts';
 import { type RefItem } from '../refs.ts';
-import type { IProjectSchema } from './types.ts';
-/**
- * Create a shape model from either a ref item or a ref string such as `rick:Character`
- */
-export declare class ShapeModel {
-    private readonly _projectSchemaModel;
-    private readonly _rawShape;
-    private readonly _shapeRefItem;
-    private readonly _shapeAtRef;
-    constructor(_projectSchemaModel: IProjectSchema, refArg: RefItem | string);
-    get json(): ShapeJSON;
-    get id(): string;
+import type { IRuntimeSchema } from './types.ts';
+export declare class Shape {
+    #private;
+    constructor(parent: IRuntimeSchema, ref: RefItem, shape: ShapeJSON);
     get name(): string;
-    get title(): string;
-    get description(): string | undefined;
-    get schema(): import("../project-schema/latest.ts").ShapeSchema;
-    get schemaPropertyList(): {
-        _propertyIterator: Map<string, import("../project-schema/latest.ts").PropertySchema>;
-        orderBy: (iteratees?: ((n: import("../types/types.ts").SchemaPropertyNode) => string)[], orders?: ("asc" | "desc")[]) => /*elided*/ any;
-        sortWith: (comparator?: (a: import("../types/types.ts").SchemaPropertyNode, b: import("../types/types.ts").SchemaPropertyNode) => number) => /*elided*/ any;
-        sortByNamesWithList: (comparatorArray?: string[]) => /*elided*/ any;
-        filterBy: (predicate: (n: import("../types/types.ts").SchemaPropertyNode) => boolean) => /*elided*/ any;
-        forEach: (iteratee: (n: import("../types/types.ts").SchemaPropertyNode) => void) => /*elided*/ any;
-        getNodes: () => import("../types/types.ts").SchemaPropertyNode[];
-        getObject: () => Record<string, import("../project-schema/latest.ts").PropertySchema>;
-        getNames: () => import("../types/types.ts").SchemaPropertyName[];
-        getValues: () => import("../project-schema/latest.ts").PropertySchema[];
-    };
-    get schemaPropertyAccessor(): import("../schema-util.ts").SchemaPropertyAccessor;
-    get refString(): string;
+    get ref(): string;
     get refItem(): RefItem;
-    get serviceId(): string;
-    get modelType(): import("../project-schema/latest.ts").ModelType | undefined;
-    get interfaces(): string[] | undefined;
-    get isModel(): boolean;
-    get isCached(): boolean;
-    get isAsset(): boolean;
-    get isInterfaceShape(): boolean;
+    getObjectSchema(): import("../project-schema/latest.ts").ObjectSchema | undefined;
 }

package/dist/models/shape.js

@@ -1,85 +1,30 @@
-import { isInterfaceShape } from "../interfaces.js";
-import { refItemToShape } from "../refs.js";
-import { createSchemaPropertyAccessor, createSchemaPropertyList, getShapeByRef } from "../schema-util.js";
-import { isCachedShape, isModelShape } from "../types/index.js";
-/**
- * Create a shape model from either a ref item or a ref string such as `rick:Character`
- */
-export class ShapeModel {
-    _projectSchemaModel;
-    _rawShape;
-    _shapeRefItem;
-    _shapeAtRef;
-    constructor(_projectSchemaModel, refArg) {
-        this._projectSchemaModel = _projectSchemaModel;
-        if (typeof refArg === 'string') {
-            const rawShape = getShapeByRef(_projectSchemaModel.json, refArg);
-            if (!rawShape) {
-                throw new Error(`Error creating shape model: ${refArg} is not in project schema`);
-            }
-            this._rawShape = rawShape;
-            this._shapeRefItem = _projectSchemaModel.atRefToRefItem(refArg);
-            this._shapeAtRef = refArg;
-        }
-        else {
-            const rawShape = refItemToShape(_projectSchemaModel.json, refArg);
-            if (!rawShape) {
-                throw new Error('Error creating shape model: ref item argument could not be resolved to a shape');
-            }
-            this._rawShape = rawShape;
-            this._shapeRefItem = refArg;
-            this._shapeAtRef = `${refArg.serviceKey}:${refArg.typeName}`;
-        }
-    }
-    get json() {
-        return this._rawShape;
-    }
-    get id() {
-        return this._rawShape.id;
+import { refItemToAtRef } from "../refs.js";
+import { isObjectSchema } from "../types/utils.js";
+export class Shape {
+    #parent;
+    #ref;
+    #shape;
+    #dereferencedSchema;
+    constructor(parent, ref, shape) {
+        this.#parent = parent;
+        this.#ref = ref;
+        this.#shape = shape;
     }
     get name() {
-        return this._rawShape.name;
-    }
-    get title() {
-        return this._rawShape.title;
-    }
-    get description() {
-        return this._rawShape.description;
-    }
-    get schema() {
-        return this._rawShape.schema;
-    }
-    get schemaPropertyList() {
-        return createSchemaPropertyList(this._projectSchemaModel.json, this._rawShape);
-    }
-    get schemaPropertyAccessor() {
-        return createSchemaPropertyAccessor(this._projectSchemaModel.json, this._rawShape);
+        return this.#shape.name;
     }
-    get refString() {
-        return this._shapeAtRef;
+    get ref() {
+        return refItemToAtRef(this.#ref);
     }
     get refItem() {
-        return this._shapeRefItem;
+        return this.#ref;
     }
-    get serviceId() {
-        return this._shapeRefItem.serviceKey;
-    }
-    get modelType() {
-        return this._rawShape.model?.type;
-    }
-    get interfaces() {
-        return this._rawShape.interfaces;
-    }
-    get isModel() {
-        return isModelShape(this._rawShape);
-    }
-    get isCached() {
-        return isCachedShape(this._rawShape);
-    }
-    get isAsset() {
-        return this._rawShape.id === 'ASSET';
-    }
-    get isInterfaceShape() {
-        return isInterfaceShape(this._rawShape);
+    getObjectSchema() {
+        if (!this.#dereferencedSchema) {
+            this.#dereferencedSchema = this.#parent.dereferenceSchema(this.#shape.schema);
+        }
+        if (isObjectSchema(this.#dereferencedSchema)) {
+            return this.#dereferencedSchema;
+        }
     }
 }

package/dist/models/types.d.ts

@@ -1,6 +1,8 @@
-import type { ProjectSchemaJSON } from '../project-schema/index.ts';
-import type { RefItem } from '../refs.ts';
-export interface IProjectSchema {
-    json: ProjectSchemaJSON;
-    atRefToRefItem: (atRef: string, template?: string) => RefItem;
+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 {
+    getShape(shapeRef: string): Shape | undefined;
+    getQuery(queryRef: string): Query | undefined;
+    dereferenceSchema(propertySchema: PropertySchema): PropertySchema;
 }

package/dist/refs.d.ts

@@ -221,6 +221,6 @@ export type QueryEntry = {
     query: QueryJSON;
     ref: PropertyRefItem;
 };
-export declare function getQuery(projectSchema: ProjectSchemaJSON, queryRef: string): Maybe<QueryEntry>;
+export declare function getQuery(projectSchema: Pick<ProjectSchemaJSON, 'services' | 'shapes' | 'queries' | 'mutations'>, queryRef: string): Maybe<QueryEntry>;
 export declare function ensureQuery(projectSchema: ProjectSchemaJSON, queryRef: string): QueryEntry;
 export declare function normalizeRefs(projectSchema: ProjectSchemaJSON, property: PropertySchema): PropertySchema;

package/dist/types/transforms.d.ts

@@ -5,7 +5,9 @@ export type KeyTransform = (name: string, schema: PropertySchema, sourceKey?: st
 export type PropertyTransform = {
     keyTransform?: KeyTransform;
     filter(schema: PropertySchema, name: string, shape?: ShapeJSON): boolean;
-    process(value: unknown, schema: PropertySchema, name: string, shape: ShapeJSON | undefined, next: (value: unknown, schema: PropertySchema, name: string) => unknown): unknown;
+    process(value: unknown, schema: PropertySchema & {
+        $parent?: PropertySchema;
+    }, name: string, shape: ShapeJSON | undefined, next: (value: unknown, schema: PropertySchema, name: string) => unknown): unknown;
 };
 export type SchemaType = '*' | 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean';
 export type PropertyTransformMap = {

package/examples/latest/rick-and-morty-user-schema.json

@@ -0,0 +1,104 @@
+{
+  "projectId": "a8b9ea5b-2522-442d-9b68-be0bef4a1a74",
+  "defaultLocale": "en-us",
+  "locales": ["en-us"],
+  "queries": {
+    "Rick_characters": {
+      "resolver": {
+        "name": "graphql:query",
+        "service": "rick",
+        "fieldName": "characters"
+      },
+      "args": {
+        "type": "object",
+        "properties": {
+          "page": { "type": "integer" },
+          "filter": { "@ref": "rick:FilterCharacter" }
+        }
+      },
+      "shape": "Rick_Characters"
+    },
+    "getIndexedRickCharacterList": {
+      "shape": "PaginatedList<Rick_Character>",
+      "resolver": {
+        "shapeName": "Rick_Character",
+        "name": "takeshape:queryApiIndex",
+        "service": "takeshape",
+        "options": { "indexedShape": "Rick_Character" }
+      },
+      "description": "Fetch Rick_Character data from the API Index.",
+      "args": "TSListArgs<Rick_Character>"
+    },
+    "Rick_character": {
+      "resolver": {
+        "name": "graphql:query",
+        "service": "rick",
+        "fieldName": "character"
+      },
+      "args": {
+        "type": "object",
+        "properties": { "id": { "type": "string", "@tag": "id" } },
+        "required": ["id"]
+      },
+      "shape": "Rick_Character"
+    }
+  },
+  "mutations": {},
+  "shapes": {
+    "Rick_Character": {
+      "id": "Rick_Character",
+      "name": "Rick_Character",
+      "title": "Rick Character",
+      "cache": {
+        "enabled": true,
+        "triggers": [{ "type": "schedule", "loader": "list", "interval": 1440 }],
+        "fragment": { "maxDepth": 2 }
+      },
+      "loaders": {
+        "list": { "query": "rick:Query.characters" },
+        "get": { "query": "rick:Query.character" }
+      },
+      "schema": {
+        "extends": [
+          { "@ref": "rick:Character" },
+          {
+            "type": "object",
+            "properties": {
+              "custom": {
+                "@mapping": "shapedb:Rick_Character.qg6KuTt2V",
+                "type": "string",
+                "title": "Custom"
+              }
+            }
+          }
+        ]
+      }
+    }
+  },
+  "workflows": {},
+  "forms": {
+    "Rick_Character": {
+      "default": {
+        "properties": { "custom": { "widget": "singleLineText" } },
+        "order": ["custom"]
+      }
+    }
+  },
+  "schemaVersion": "3.53.0",
+  "apiVersion": "2",
+  "services": {
+    "rick": {
+      "id": "rick",
+      "title": "Rick",
+      "namespace": "Rick",
+      "provider": "graphql",
+      "serviceType": "graphql",
+      "authenticationType": "none",
+      "options": {
+        "endpoint": "https://rickandmortyapi.com/graphql",
+        "introspectedAt": "2025-04-23T18:13:21.722Z"
+      },
+      "healthCheck": { "checkName": "graphqlIntrospection" }
+    }
+  }
+}

package/examples/source/rick-and-morty-user-schema.json

@@ -0,0 +1,104 @@
+{
+  "projectId": "a8b9ea5b-2522-442d-9b68-be0bef4a1a74",
+  "defaultLocale": "en-us",
+  "locales": ["en-us"],
+  "queries": {
+    "Rick_characters": {
+      "resolver": {
+        "name": "graphql:query",
+        "service": "rick",
+        "fieldName": "characters"
+      },
+      "args": {
+        "type": "object",
+        "properties": {
+          "page": { "type": "integer" },
+          "filter": { "@ref": "rick:FilterCharacter" }
+        }
+      },
+      "shape": "Rick_Characters"
+    },
+    "getIndexedRickCharacterList": {
+      "shape": "PaginatedList<Rick_Character>",
+      "resolver": {
+        "shapeName": "Rick_Character",
+        "name": "takeshape:queryApiIndex",
+        "service": "takeshape",
+        "options": { "indexedShape": "Rick_Character" }
+      },
+      "description": "Fetch Rick_Character data from the API Index.",
+      "args": "TSListArgs<Rick_Character>"
+    },
+    "Rick_character": {
+      "resolver": {
+        "name": "graphql:query",
+        "service": "rick",
+        "fieldName": "character"
+      },
+      "args": {
+        "type": "object",
+        "properties": { "id": { "type": "string", "@tag": "id" } },
+        "required": ["id"]
+      },
+      "shape": "Rick_Character"
+    }
+  },
+  "mutations": {},
+  "shapes": {
+    "Rick_Character": {
+      "id": "Rick_Character",
+      "name": "Rick_Character",
+      "title": "Rick Character",
+      "cache": {
+        "enabled": true,
+        "triggers": [{ "type": "schedule", "loader": "list", "interval": 1440 }],
+        "fragment": { "maxDepth": 2 }
+      },
+      "loaders": {
+        "list": { "query": "rick:Query.characters" },
+        "get": { "query": "rick:Query.character" }
+      },
+      "schema": {
+        "extends": [
+          { "@ref": "rick:Character" },
+          {
+            "type": "object",
+            "properties": {
+              "custom": {
+                "@mapping": "shapedb:Rick_Character.qg6KuTt2V",
+                "type": "string",
+                "title": "Custom"
+              }
+            }
+          }
+        ]
+      }
+    }
+  },
+  "workflows": {},
+  "forms": {
+    "Rick_Character": {
+      "default": {
+        "properties": { "custom": { "widget": "singleLineText" } },
+        "order": ["custom"]
+      }
+    }
+  },
+  "schemaVersion": "3.53.0",
+  "apiVersion": "2",
+  "services": {
+    "rick": {
+      "id": "rick",
+      "title": "Rick",
+      "namespace": "Rick",
+      "provider": "graphql",
+      "serviceType": "graphql",
+      "authenticationType": "none",
+      "options": {
+        "endpoint": "https://rickandmortyapi.com/graphql",
+        "introspectedAt": "2025-04-23T18:13:21.722Z"
+      },
+      "healthCheck": { "checkName": "graphqlIntrospection" }
+    }
+  }
+}

package/package.json

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

package/dist/models/__tests__/project-schema.test.js

@@ -1,67 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
-import { ProjectSchema } from "../project-schema.js";
-import { QueryModel } from "../query.js";
-import { ServiceConfig } from "../service.js";
-import { ShapeModel } from "../shape.js";
-const projectSchema = shopifySchemaJson;
-describe('ProjectSchemaModel', () => {
-    const projectSchemaModel = new ProjectSchema(projectSchema);
-    test('basic accessors', () => {
-        expect(projectSchemaModel.json).toEqual(projectSchema);
-        expect(projectSchemaModel.projectId).toEqual(projectSchema.projectId);
-        expect(projectSchemaModel.$schema).toEqual(projectSchema.$schema);
-        expect(projectSchemaModel.author).toEqual(projectSchema.author);
-        expect(projectSchemaModel.getShapeByName('Asset') instanceof ShapeModel).toEqual(true);
-        expect(projectSchemaModel.getShapeByName('Bogus')).toBeUndefined();
-        expect(projectSchemaModel.getShapeById('ASSET') instanceof ShapeModel).toEqual(true);
-        expect(projectSchemaModel.getShapeById('Bogus')).toBeUndefined();
-        expect(projectSchemaModel.getShapeByRef('local:Asset') instanceof ShapeModel).toEqual(true);
-        expect(projectSchemaModel.refs.length).toEqual(429);
-        expect(projectSchemaModel.getQueryByName('getAssetList') instanceof QueryModel).toEqual(true);
-        expect(projectSchemaModel.getMutationByName('updateAsset') instanceof QueryModel).toEqual(true);
-        expect(projectSchemaModel.getServiceById('gregs-takeshape-store') instanceof ServiceConfig).toEqual(true);
-    });
-    test('getShapeByName', () => {
-        expect(projectSchemaModel.getShapeByRef('local:Asset') instanceof ShapeModel).toEqual(true);
-    });
-    test('allShapes', () => {
-        const allShapes = projectSchemaModel.shapes;
-        expect(allShapes.length).toEqual(213);
-        for (const shapeModel of allShapes) {
-            expect(shapeModel instanceof ShapeModel).toEqual(true);
-        }
-    });
-    test('queries', () => {
-        const queries = projectSchemaModel.queries;
-        expect(queries.length).toEqual(8);
-        for (const queryModel of queries) {
-            expect(queryModel instanceof QueryModel).toEqual(true);
-        }
-    });
-    test('mutations', () => {
-        const mutations = projectSchemaModel.mutations;
-        expect(mutations.length).toEqual(18);
-        for (const mutationModel of mutations) {
-            expect(mutationModel instanceof QueryModel).toEqual(true);
-        }
-    });
-    test('basic utils', () => {
-        const assetName = 'Asset';
-        const assetAtRef = 'local:Asset';
-        const assetRefItem = {
-            isForeign: false,
-            serviceKey: 'local',
-            typeName: assetName,
-            isValidService: true
-        };
-        const assetRefSchema = {
-            '@ref': assetAtRef
-        };
-        expect(projectSchemaModel.atRefToRefItem(assetAtRef)).toEqual(assetRefItem);
-        expect(projectSchemaModel.refItemToShape(assetRefItem) instanceof ShapeModel).toEqual(true);
-        expect(projectSchemaModel.getRef(assetRefSchema)).toEqual(assetRefItem);
-        expect(projectSchemaModel.normalizeRefExpression(assetName)).toEqual(assetAtRef);
-        expect(projectSchemaModel.refExpressionToRefItem(assetName)).toEqual(assetRefItem);
-    });
-});

package/dist/models/__tests__/service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/models/__tests__/service.test.js

@@ -1,17 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
-import { ProjectSchema } from "../project-schema.js";
-import { ServiceConfig } from "../service.js";
-const projectSchema = shopifySchemaJson;
-const projectSchemaModel = new ProjectSchema(projectSchema);
-describe('ServiceModel', () => {
-    const serviceId = 'gregs-takeshape-store';
-    const serviceModel = new ServiceConfig(projectSchemaModel, serviceId);
-    test('invalid service id', () => {
-        expect(() => new ServiceConfig(projectSchemaModel, 'bogus')).toThrowError(new Error('Could not create service model for bogus'));
-    });
-    test('basic accessors', () => {
-        expect(serviceModel.id).toEqual(serviceId);
-        expect(serviceModel.json).toEqual(projectSchema.services[serviceId]);
-    });
-});

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

@@ -1,36 +0,0 @@
-import type { ProjectSchemaJSON, ShapeJSON } from '../project-schema/index.ts';
-import { type RefItem, type RefItemWithPath } from '../refs.ts';
-import type { SchemaWithRef } from '../types/index.ts';
-import { QueryModel } from './query.ts';
-import { ServiceConfig } from './service.ts';
-import { ShapeModel } from './shape.ts';
-import type { IProjectSchema } from './types.ts';
-/**
- * Model object representing a ProjectSchema.
- * Intended to help make it easier to find the right utils
- * and avoid direct schema json access where a util would be preferred.
- */
-export declare class ProjectSchema implements IProjectSchema {
-    private readonly _projectSchemaJSON;
-    private readonly _cache;
-    constructor(unfilteredProjectSchema: ProjectSchemaJSON);
-    get json(): ProjectSchemaJSON;
-    get projectId(): string;
-    get $schema(): string | undefined;
-    get author(): string | undefined;
-    getShapeByName(shapeName: string): ShapeModel | undefined;
-    getShapeById(shapeId: string): ShapeModel | undefined;
-    getShapeByRef(shapeRef: string): ShapeModel;
-    get shapes(): ShapeJSON[];
-    get refs(): RefItemWithPath[];
-    getQueryByName(queryName: string): QueryModel;
-    get queries(): QueryModel[];
-    getMutationByName(mutationName: string): QueryModel;
-    get mutations(): QueryModel[];
-    getServiceById(serviceId: string): ServiceConfig;
-    atRefToRefItem(atRef: string, template?: string): RefItem;
-    refItemToShape(refItem: RefItem): ShapeModel;
-    getRef(refSchema: SchemaWithRef): import("@takeshape/util").Maybe<RefItem>;
-    normalizeRefExpression(refExpression: string): string;
-    refExpressionToRefItem(refExpression: string): RefItem;
-}

package/dist/models/project-schema.js

@@ -1,92 +0,0 @@
-import omit from 'lodash/omit.js';
-import { atRefToRefItem, getRef, normalizeRefExpression, refExpressionToRefItem, shapeToRefItem } from "../refs.js";
-import { getAllRefs } from "../schema-util.js";
-import { getShape, getShapeById } from "../util/shapes.js";
-import { QueryModel } from "./query.js";
-import { ServiceConfig } from "./service.js";
-import { ShapeModel } from "./shape.js";
-/**
- * Model object representing a ProjectSchema.
- * Intended to help make it easier to find the right utils
- * and avoid direct schema json access where a util would be preferred.
- */
-export class ProjectSchema {
-    _projectSchemaJSON;
-    _cache = {};
-    constructor(unfilteredProjectSchema) {
-        // You can pass a ProjectSchemaCompat in here, but we remove its values so they don't get passed through to getJSON.
-        // If you need to use this metadata it should be stored separately.
-        this._projectSchemaJSON = omit(unfilteredProjectSchema, ['created', 'updated', 'version']);
-    }
-    get json() {
-        return this._projectSchemaJSON;
-    }
-    get projectId() {
-        return this.json.projectId;
-    }
-    get $schema() {
-        return this.json.$schema;
-    }
-    get author() {
-        return this.json.author;
-    }
-    getShapeByName(shapeName) {
-        const shapeJSON = getShape(this.json, shapeName);
-        if (!shapeJSON) {
-            return undefined;
-        }
-        const shapeRefItem = shapeToRefItem(this.json, shapeJSON);
-        return new ShapeModel(this, shapeRefItem);
-    }
-    getShapeById(shapeId) {
-        const shapeJSON = getShapeById(this.json, shapeId);
-        if (!shapeJSON) {
-            return undefined;
-        }
-        const shapeRefItem = shapeToRefItem(this.json, shapeJSON);
-        return new ShapeModel(this, shapeRefItem);
-    }
-    getShapeByRef(shapeRef) {
-        return new ShapeModel(this, shapeRef);
-    }
-    get shapes() {
-        this._cache.shapes ??= Object.keys(this.json.shapes).map((name) => new ShapeModel(this, normalizeRefExpression(this.json, name)));
-        return this._cache.shapes;
-    }
-    get refs() {
-        this._cache.refs ??= getAllRefs(this.json);
-        return this._cache.refs;
-    }
-    getQueryByName(queryName) {
-        return new QueryModel(this, 'query', queryName);
-    }
-    get queries() {
-        this._cache.queries ??= Object.keys(this.json.queries).map((name) => new QueryModel(this, 'query', name));
-        return this._cache.queries;
-    }
-    getMutationByName(mutationName) {
-        return new QueryModel(this, 'mutation', mutationName);
-    }
-    get mutations() {
-        this._cache.mutations = Object.keys(this.json.mutations).map((name) => new QueryModel(this, 'mutation', name));
-        return this._cache.mutations;
-    }
-    getServiceById(serviceId) {
-        return new ServiceConfig(this, serviceId);
-    }
-    atRefToRefItem(atRef, template) {
-        return atRefToRefItem(this.json, atRef, template);
-    }
-    refItemToShape(refItem) {
-        return new ShapeModel(this, refItem);
-    }
-    getRef(refSchema) {
-        return getRef(this.json, refSchema);
-    }
-    normalizeRefExpression(refExpression) {
-        return normalizeRefExpression(this.json, refExpression);
-    }
-    refExpressionToRefItem(refExpression) {
-        return refExpressionToRefItem(this.json, refExpression);
-    }
-}

package/dist/models/service.d.ts

@@ -1,12 +0,0 @@
-import type { ServiceConfigJSON } from '../project-schema/index.ts';
-import type { IProjectSchema } from './types.ts';
-/**
- * Create a model object representing a service configuration.
- */
-export declare class ServiceConfig {
-    private readonly _serviceId;
-    private readonly _storedServiceConfig;
-    constructor(projectSchemaModel: IProjectSchema, _serviceId: string);
-    get id(): string;
-    get json(): ServiceConfigJSON;
-}

package/dist/models/service.js

@@ -1,20 +0,0 @@
-/**
- * Create a model object representing a service configuration.
- */
-export class ServiceConfig {
-    _serviceId;
-    _storedServiceConfig;
-    constructor(projectSchemaModel, _serviceId) {
-        this._serviceId = _serviceId;
-        if (!projectSchemaModel.json.services?.[_serviceId]) {
-            throw new Error(`Could not create service model for ${_serviceId}`);
-        }
-        this._storedServiceConfig = projectSchemaModel.json.services[_serviceId];
-    }
-    get id() {
-        return this._serviceId;
-    }
-    get json() {
-        return this._storedServiceConfig;
-    }
-}