@takeshape/schema 11.52.0 → 11.56.1

package/dist/migration/to/v3.32.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_31_0, ProjectSchemaJSONV3_32_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_31_0, ProjectSchemaJSONV3_32_0>;
+export default migrate;

package/dist/migration/to/v3.32.0.js

@@ -0,0 +1,59 @@
+import { normalizeRefExpression } from "../../refs.js";
+function migrateListQuery(listConfig) {
+    const { pagination, name, ...restConfig } = listConfig;
+    const result = { ...restConfig, query: name };
+    if (pagination) {
+        const { itemsToIndexPath, ...restPagination } = pagination;
+        result.pagination = { ...restPagination, itemsPath: itemsToIndexPath };
+    }
+    return result;
+}
+function queriesToLoaders(queries) {
+    if (queries.list) {
+        const loaders = {
+            list: Array.isArray(queries.list) ? queries.list.map(migrateListQuery) : migrateListQuery(queries.list)
+        };
+        if (queries.get) {
+            const { name, ...restGet } = queries.get;
+            loaders.get = { ...restGet, query: name };
+        }
+        return loaders;
+    }
+}
+function migrateTrigger(trigger) {
+    const { query, ...rest } = trigger;
+    return { ...rest, loader: query };
+}
+const migrate = async (_, projectSchema) => {
+    const updatedShapes = { ...projectSchema.shapes };
+    const { indexedShapes, ...rest } = projectSchema;
+    if (indexedShapes) {
+        for (const [name, config] of Object.entries(indexedShapes)) {
+            let shape = updatedShapes[name];
+            shape ||= {
+                name,
+                id: name,
+                title: name,
+                schema: {
+                    extends: [{ '@ref': normalizeRefExpression(projectSchema, name) }]
+                }
+            };
+            const loaders = queriesToLoaders(config.queries);
+            if (loaders) {
+                shape.loaders = loaders;
+            }
+            shape.cache = {
+                enabled: true,
+                fragment: config.query,
+                triggers: config.triggers.map(migrateTrigger)
+            };
+            updatedShapes[name] = shape;
+        }
+    }
+    return {
+        ...rest,
+        shapes: updatedShapes,
+        schemaVersion: '3.32.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.33.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_32_0, ProjectSchemaJSONV3_33_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_32_0, ProjectSchemaJSONV3_33_0>;
+export default migrate;

package/dist/migration/to/v3.34.0.d.ts

@@ -0,0 +1,6 @@
+import type { FormMapV3_33_0, ProjectSchemaJSONV3_33_0, ProjectSchemaJSONV3_34_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+export declare function normalizeForms(projectSchema: ProjectSchemaJSONV3_33_0): FormMapV3_33_0;
+export declare function migrateInterfaceShapes(projectSchema: ProjectSchemaJSONV3_33_0): ProjectSchemaJSONV3_33_0;
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_33_0, ProjectSchemaJSONV3_34_0>;
+export default migrate;

package/dist/migration/to/v3.34.0.js

@@ -0,0 +1,116 @@
+import { deepClone } from '@takeshape/util';
+import set from 'lodash/fp/set.js';
+import unset from 'lodash/fp/unset.js';
+import upperFirst from 'lodash/upperFirst.js';
+import { SERVICE_OBJECT_PATTERN_NAME } from "../../constants.js";
+import { getRefOrItemsRef } from "../../refs.js";
+import { createSchemaPropertyAccessor } from "../../schema-util.js";
+import { CURRENT_SCHEMA_VERSION } from "../../schemas/index.js";
+import { getServiceObjectFields } from "../../services/services.js";
+// Inline utilities for posterity
+function refItemToShapeName(refItem) {
+    const { serviceNamespace, typeName } = refItem;
+    return serviceNamespace ? `${serviceNamespace}_${typeName}` : typeName;
+}
+// Map of form studio widgets and their replacements in the shape editor
+const widgetMigrations = {
+    object: 'shapeObject',
+    repeater: 'shapeArray'
+};
+export function normalizeForms(projectSchema) {
+    const normalizedForms = {};
+    const { forms = {} } = projectSchema;
+    const storeSourceForm = (shapeName, formConfig, propName) => {
+        normalizedForms[shapeName] ||= { default: deepClone(formConfig) };
+        const propConfig = normalizedForms[shapeName].default.properties[propName];
+        propConfig.properties = undefined;
+        propConfig.order = undefined;
+        propConfig.widget = widgetMigrations[propConfig.widget] ?? propConfig.widget;
+    };
+    const normalizeNested = (shapeName, formConfig) => {
+        const shape = projectSchema.shapes[shapeName];
+        if (!shape || !formConfig.properties) {
+            return;
+        }
+        const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
+        for (const propName of Object.keys(formConfig.properties)) {
+            const propConfig = formConfig.properties[propName];
+            const propSchema = propertyAccessor.getValue(propName);
+            if (propSchema) {
+                const ref = getRefOrItemsRef(projectSchema, propSchema);
+                if (ref && propConfig.properties && propConfig.widget !== 'shopify') {
+                    const nestedShapeName = refItemToShapeName(ref);
+                    normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
+                    storeSourceForm(shapeName, formConfig, propName);
+                    normalizeNested(nestedShapeName, propConfig);
+                }
+            }
+        }
+    };
+    if (forms) {
+        for (const shapeName of Object.keys(forms)) {
+            normalizeNested(shapeName, forms[shapeName].default);
+            // copy forms with no changes
+            normalizedForms[shapeName] ||= forms[shapeName];
+        }
+    }
+    return normalizedForms;
+}
+export function migrateInterfaceShapes(projectSchema) {
+    let updatedProjectSchema = projectSchema;
+    for (const shape of Object.values(projectSchema.shapes)) {
+        if (!shape.model) {
+            continue;
+        }
+        // Set the schema version to the current to appease type check this line will eventually break as the schema diverges
+        const serviceObjectFields = getServiceObjectFields({ ...projectSchema, schemaVersion: CURRENT_SCHEMA_VERSION }, shape, 'shopify');
+        for (const field of serviceObjectFields) {
+            const { fieldName, service } = field;
+            const { serviceObjectType } = field.generators[SERVICE_OBJECT_PATTERN_NAME];
+            const serviceShapeName = upperFirst(serviceObjectType);
+            const interfaceShapeName = `${serviceShapeName}Interface`;
+            updatedProjectSchema = unset(['shapes', interfaceShapeName], updatedProjectSchema);
+            if ('type' in shape.schema && shape.schema.type === 'object') {
+                const prop = shape.schema.properties[fieldName];
+                if (prop) {
+                    updatedProjectSchema = set(['shapes', shape.name, 'schema', 'properties', fieldName, '@input'], { '@ref': `${service}:${serviceShapeName}Input` }, updatedProjectSchema);
+                }
+            }
+            for (const [mutationName, mutation] of Object.entries(projectSchema.mutations)) {
+                if (!mutation || typeof mutation.args !== 'string') {
+                    continue;
+                }
+                for (const template of ['CreateArgs', 'UpdateArgs']) {
+                    if (mutation.args === `${template}<${interfaceShapeName}>`) {
+                        updatedProjectSchema = set(['mutations', mutationName], { ...mutation, args: `${template}<${serviceShapeName}>` }, updatedProjectSchema);
+                    }
+                }
+            }
+        }
+    }
+    return updatedProjectSchema;
+}
+const migrate = async (_, projectSchema) => {
+    let normalized = projectSchema;
+    try {
+        normalized = {
+            ...projectSchema,
+            forms: normalizeForms(projectSchema)
+        };
+    }
+    catch (e) {
+        // TODO remove console.log when a formal warning mechanism is added https://app.shortcut.com/takeshape/story/11533/return-warnings-from-schema-migration
+        console.info('v3.34.0 migration warning: Failed to normalize forms', e.message);
+    }
+    try {
+        normalized = migrateInterfaceShapes(normalized);
+    }
+    catch (e) {
+        console.info('v3.34.0 migration warning: Failed to migrate interface shapes', e.message);
+    }
+    return {
+        ...normalized,
+        schemaVersion: '3.34.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.35.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_34_0, ProjectSchemaJSONV3_35_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_34_0, ProjectSchemaJSONV3_35_0>;
+export default migrate;

package/dist/migration/to/v3.36.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_35_0, ProjectSchemaJSONV3_36_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_35_0, ProjectSchemaJSONV3_36_0>;
+export default migrate;

package/dist/migration/to/v3.37.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_36_0, ProjectSchemaJSONV3_37_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_36_0, ProjectSchemaJSONV3_37_0>;
+export default migrate;

package/dist/migration/to/v3.38.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_37_0, ProjectSchemaJSONV3_38_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_37_0, ProjectSchemaJSONV3_38_0>;
+export default migrate;

package/dist/migration/to/v3.39.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_38_0, ProjectSchemaJSONV3_39_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_38_0, ProjectSchemaJSONV3_39_0>;
+export default migrate;

package/dist/migration/to/v3.39.0.js

@@ -0,0 +1,45 @@
+import { isSearchParamsAuthentication, isServiceAuthentication } from "../../types/index.js";
+const migrate = async ({ decryptFn, encryptFn }, projectSchema) => {
+    /**
+     * Move unencrypted searchParams out of the authentication object.
+     */
+    for (const serviceConfig of Object.values(projectSchema.services ?? {})) {
+        if (serviceConfig.authentication) {
+            const authentication = decryptFn(serviceConfig.authentication);
+            if (isServiceAuthentication(authentication) && isSearchParamsAuthentication(authentication)) {
+                if (serviceConfig.provider === 'judgeMe') {
+                    const shopDomain = authentication.params.find((param) => param.name === 'shop_domain');
+                    if (shopDomain) {
+                        serviceConfig.options = {
+                            ...serviceConfig.options,
+                            searchParams: {
+                                shop_domain: shopDomain.value
+                            }
+                        };
+                        serviceConfig.options.shopDomain = undefined;
+                    }
+                    authentication.params = authentication.params.filter((param) => param.name !== 'shop_domain');
+                }
+                if (serviceConfig.provider === 'reviewsIo') {
+                    const storeId = authentication.params.find((param) => param.name === 'store');
+                    if (storeId) {
+                        serviceConfig.options = {
+                            ...serviceConfig.options,
+                            searchParams: {
+                                store: storeId.value
+                            }
+                        };
+                        serviceConfig.options.storeId = undefined;
+                    }
+                    authentication.params = authentication.params.filter((param) => param.name !== 'store');
+                }
+                serviceConfig.authentication = encryptFn(authentication);
+            }
+        }
+    }
+    return {
+        ...projectSchema,
+        schemaVersion: '3.39.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.4.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_3_0, ProjectSchemaJSONV3_4_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_3_0, ProjectSchemaJSONV3_4_0>;
+export default migrate;

package/dist/migration/to/v3.40.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_39_0, ProjectSchemaJSONV3_40_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_39_0, ProjectSchemaJSONV3_40_0>;
+export default migrate;

package/dist/migration/to/v3.41.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_40_0, ProjectSchemaJSONV3_41_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_40_0, ProjectSchemaJSONV3_41_0>;
+export default migrate;

package/dist/migration/to/v3.42.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_41_0, ProjectSchemaJSONV3_42_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_41_0, ProjectSchemaJSONV3_42_0>;
+export default migrate;

package/dist/migration/to/v3.43.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_42_0, ProjectSchemaJSONV3_43_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_42_0, ProjectSchemaJSONV3_43_0>;
+export default migrate;

package/dist/migration/to/v3.44.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_43_0, ProjectSchemaJSONV3_44_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_43_0, ProjectSchemaJSONV3_44_0>;
+export default migrate;

package/dist/migration/to/v3.45.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_44_0, ProjectSchemaJSONV3_45_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_44_0, ProjectSchemaJSONV3_45_0>;
+export default migrate;

package/dist/migration/to/v3.46.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_45_0, ProjectSchemaJSONV3_46_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_45_0, ProjectSchemaJSONV3_46_0>;
+export default migrate;

package/dist/migration/to/v3.47.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_46_0, ProjectSchemaJSONV3_47_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_46_0, ProjectSchemaJSONV3_47_0>;
+export default migrate;

package/dist/migration/to/v3.48.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_47_0, ProjectSchemaJSONV3_48_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_47_0, ProjectSchemaJSONV3_48_0>;
+export default migrate;

package/dist/migration/to/v3.49.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_48_0, ProjectSchemaJSONV3_49_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_48_0, ProjectSchemaJSONV3_49_0>;
+export default migrate;

package/dist/migration/to/v3.5.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_4_0, ProjectSchemaJSONV3_5_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_4_0, ProjectSchemaJSONV3_5_0>;
+export default migrate;

package/dist/migration/to/v3.5.1.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_5_0, ProjectSchemaJSONV3_5_1 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_5_0, ProjectSchemaJSONV3_5_1>;
+export default migrate;

package/dist/migration/to/v3.50.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_49_0, ProjectSchemaJSONV3_50_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_49_0, ProjectSchemaJSONV3_50_0>;
+export default migrate;

package/dist/migration/to/v3.51.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_50_0, ProjectSchemaJSONV3_51_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_50_0, ProjectSchemaJSONV3_51_0>;
+export default migrate;

package/dist/migration/to/v3.6.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_5_1, ProjectSchemaJSONV3_6_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_5_1, ProjectSchemaJSONV3_6_0>;
+export default migrate;

package/dist/migration/to/v3.7.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_6_0, ProjectSchemaJSONV3_7_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_6_0, ProjectSchemaJSONV3_7_0>;
+export default migrate;

package/dist/migration/to/v3.8.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_7_0, ProjectSchemaJSONV3_8_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_7_0, ProjectSchemaJSONV3_8_0>;
+export default migrate;

package/dist/migration/to/v3.9.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_8_0, ProjectSchemaJSONV3_9_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_8_0, ProjectSchemaJSONV3_9_0>;
+export default migrate;

package/dist/migration/types.d.ts

@@ -0,0 +1,19 @@
+import type { AgentJSON, FormConfig, GuardJSON, ProjectSchemaJSON, QueryJSON, ServiceConfigJSON, ShapeJSON, Workflow } from '../project-schema/index.ts';
+import type { EncryptFn, SafeDecryptFn } from '../services/types.ts';
+export type ProjectSchemaMigrationContext = {
+    generateDataKeyFn: () => Promise<string>;
+    encryptFn: EncryptFn;
+    decryptFn: SafeDecryptFn;
+};
+export type ProjectSchemaUpdate = {
+    queries?: Record<string, QueryJSON | null>;
+    mutations?: Record<string, QueryJSON | null>;
+    shapes?: Record<string, ShapeJSON | null>;
+    'ai-experimental.agents'?: Record<string, AgentJSON | null>;
+    'ai-experimental.guards'?: Record<string, GuardJSON | null>;
+    forms?: Record<string, FormConfig | null>;
+    workflows?: Record<string, Workflow | null>;
+    services?: Record<string, ServiceConfigJSON | null>;
+    deactivated?: number;
+} & Omit<Partial<ProjectSchemaJSON>, 'queries' | 'mutations' | 'shapes' | 'ai-experimental' | 'forms' | 'workflows' | 'services'>;
+export type MigrateFunction<FromSchema, ToSchema> = (context: ProjectSchemaMigrationContext, fromSchema: FromSchema) => Promise<ToSchema>;

package/dist/migration/types.js

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

package/dist/mocks.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectSchemaJSON, ServiceConfig, ServiceConfigJSON, ShapeJSON } from './project-schema/index.ts';
+import type { CachedShape, ServiceKey } from './types/types.ts';
+/**
+ * Like emptySchema, but for tests.
+ */
+export declare function createMockSchema(projectId: string, schema?: Partial<ProjectSchemaJSON>): ProjectSchemaJSON;
+/**
+ * Capturing a common pattern used in tests. Creates an empty schema, with defaults.
+ */
+export declare function createMockSchemaWithDefaults(projectId: string, schema?: Partial<ProjectSchemaJSON>): ProjectSchemaJSON;
+export declare function createMockServiceConfig(serviceKey: ServiceKey, serviceConfig?: Partial<ServiceConfig>): ServiceConfig;
+export declare function createMockStoredServiceConfig(serviceKey: ServiceKey, serviceConfig?: Partial<ServiceConfigJSON>): ServiceConfigJSON;
+export declare function addMockIndexingConfig(shape: ShapeJSON): CachedShape;

package/dist/mocks.js

@@ -0,0 +1,58 @@
+import { pascalCase } from '@takeshape/util';
+import { applyDefaultsToSchema, emptySchema } from "./schema-util.js";
+/**
+ * Like emptySchema, but for tests.
+ */
+export function createMockSchema(projectId, schema = {}) {
+    return {
+        ...emptySchema(projectId),
+        ...schema,
+        projectId
+    };
+}
+/**
+ * Capturing a common pattern used in tests. Creates an empty schema, with defaults.
+ */
+export function createMockSchemaWithDefaults(projectId, schema = {}) {
+    return applyDefaultsToSchema({
+        ...emptySchema(projectId),
+        ...schema,
+        projectId
+    });
+}
+export function createMockServiceConfig(serviceKey, serviceConfig) {
+    return {
+        id: serviceKey,
+        title: pascalCase(serviceKey),
+        provider: 'graphql',
+        serviceType: 'graphql',
+        namespace: pascalCase(serviceKey),
+        authenticationType: 'bearer',
+        authentication: {
+            type: 'bearer',
+            token: 'abc123'
+        },
+        options: {
+            endpoint: 'https://example.test/graphql'
+        },
+        ...serviceConfig
+    };
+}
+export function createMockStoredServiceConfig(serviceKey, serviceConfig) {
+    return {
+        ...createMockServiceConfig(serviceKey),
+        authentication: 'encrypted-abc123',
+        ...serviceConfig
+    };
+}
+export function addMockIndexingConfig(shape) {
+    return {
+        ...shape,
+        loaders: {
+            list: {
+                query: `Query.get${shape.name}List`
+            }
+        },
+        cache: { enabled: true }
+    };
+}

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

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

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

@@ -0,0 +1,67 @@
+import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
+import { describe, expect, test } from 'vitest';
+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__/query.test.d.ts

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

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

@@ -0,0 +1,27 @@
+import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
+import { describe, expect, test } from 'vitest';
+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);
+    });
+    test('can create from mutation', () => {
+        const queryModelFromMutation = new QueryModel(projectSchemaModel, 'mutation', 'updateAsset');
+        expect(queryModelFromMutation instanceof QueryModel).toEqual(true);
+    });
+    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);
+    });
+});

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

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

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

@@ -0,0 +1,17 @@
+import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
+import { describe, expect, test } from 'vitest';
+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/__tests__/shape.test.d.ts

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