@takeshape/schema 11.52.0 → 11.55.0

package/dist/service-dependencies.js

@@ -0,0 +1,165 @@
+import { addAll, deepClone, mapSet } from '@takeshape/util';
+import get from 'lodash/get.js';
+import isObject from 'lodash/isObject.js';
+import pick from 'lodash/pick.js';
+import set from 'lodash/set.js';
+import { getImplementationShapeNameMap, isInterfaceShape, pruneUnusedInterfaces } from "./interfaces.js";
+import { createGetNamespace, dereferenceObjectSchema, getAllPropertyRefs, getRef, getRefShapeName, propertyRefItemToPath, refExpressionToRefItem, refItemToNamespacedShapeName } from "./refs.js";
+import { getAllNamespaceShapes, getAllRefsInQuery, getArgsReference, isValidRefItem, visitSchemaProperties } from "./schema-util.js";
+import { isExtendsSchema, isObjectSchema, isProjectSchemaWithServices } from "./types/index.js";
+function getGraphQLServiceShapeMap(layers) {
+    return Object.assign({}, ...Object.values(layers).map((layer) => layer.schema?.shapes ?? {}));
+}
+function schemaExtendsShape(context, shapeName, schema) {
+    return (isExtendsSchema(schema) &&
+        schema.extends.some((item) => getRefShapeName(context, item) === shapeName));
+}
+function getMissingPropertyRefs(projectSchema, getNamespace) {
+    const propertyRefs = getAllPropertyRefs(projectSchema);
+    return propertyRefs.filter((ref) => {
+        const path = propertyRefItemToPath(getNamespace, ref);
+        return !get(projectSchema, path);
+    });
+}
+function refToQuery(serviceSchemas, ref) {
+    const serviceSchema = serviceSchemas[ref.serviceId]?.schema;
+    if (serviceSchema) {
+        if (ref.shapeName === 'Query' || ref.shapeName === 'Mutation') {
+            const operation = ref.shapeName === 'Query' ? 'queries' : 'mutations';
+            return serviceSchema[operation][ref.propertyName];
+        }
+    }
+}
+function getShapeRefs(services, serviceSchemas, propertyRefs) {
+    const results = [];
+    for (const ref of propertyRefs) {
+        const query = refToQuery(serviceSchemas, ref);
+        const layerSchema = serviceSchemas[ref.serviceId]?.schema;
+        if (query && layerSchema) {
+            const layerWithService = {
+                ...layerSchema,
+                services: pick(services, [ref.serviceId]) // include own service so refs have isValidService: true
+            };
+            results.push(...getAllRefsInQuery(layerWithService, [], query));
+        }
+    }
+    return results;
+}
+function interfacesToShapeNames(projectSchema, shapeRefArray) {
+    return shapeRefArray.map((shapeRef) => refItemToNamespacedShapeName(refExpressionToRefItem(projectSchema, shapeRef)));
+}
+/**
+ * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
+ */
+export function collectReferencedShapeNames(context, shapeNames) {
+    const addRef = (refItem) => {
+        shapeNames.add(refItemToNamespacedShapeName(refItem));
+    };
+    const collect = (schema) => {
+        const args = schema['@args'];
+        if (args && isObject(args) && isObjectSchema(args)) {
+            Object.values(args.properties).forEach(collect);
+        }
+        const argsRefItem = getArgsReference(context, schema);
+        if (argsRefItem) {
+            addRef(argsRefItem);
+        }
+        const refItem = getRef(context, schema);
+        if (refItem) {
+            addRef(refItem);
+        }
+    };
+    return collect;
+}
+/**
+ * Returns a schema with all of its dependencies resolved.
+ * SHOULD only return the minimum set of remote dependencies required to enable
+ * the local shape definitions.
+ */
+export function resolveSchemaShapeDependencies(projectSchema, serviceLayers) {
+    const newSchema = deepClone(projectSchema);
+    if (isProjectSchemaWithServices(projectSchema)) {
+        const newShapeMap = {};
+        const requiredShapeNames = new Set(getAllNamespaceShapes(projectSchema));
+        const getNamespace = createGetNamespace(projectSchema);
+        const missingPropertyRefs = getMissingPropertyRefs(projectSchema, getNamespace);
+        if (requiredShapeNames.size || missingPropertyRefs.length) {
+            const remoteShapeMap = getGraphQLServiceShapeMap(serviceLayers);
+            // Add shape references from queries
+            addAll(requiredShapeNames, getShapeRefs(projectSchema.services, serviceLayers, missingPropertyRefs)
+                .filter(isValidRefItem)
+                .map(refItemToNamespacedShapeName));
+            // Add referenced queries and mutations
+            for (const ref of missingPropertyRefs) {
+                const query = refToQuery(serviceLayers, ref);
+                if (query) {
+                    set(newSchema, propertyRefItemToPath(getNamespace, ref), query);
+                }
+            }
+            // Gather all the remote dependencies that our local schema requires.
+            // If the required shape exists in the remote shape map, visit the
+            // properties on the remote shape's schema and ensure they are required
+            // as well.
+            const collectDependencies = (shapeNames) => {
+                for (const name of shapeNames) {
+                    const localShape = newSchema.shapes[name];
+                    const remoteShape = remoteShapeMap[name];
+                    // Don't check for dependencies if the shape is already in our schema unless it extends a remote shape
+                    // getNamespacedShapeNameList already collected those dependencies
+                    if ((!localShape || (localShape && schemaExtendsShape(projectSchema, name, localShape.schema))) &&
+                        remoteShape) {
+                        visitSchemaProperties(remoteShape.schema, [remoteShape.name, 'schema'], collectReferencedShapeNames({ services: newSchema.services }, shapeNames));
+                    }
+                }
+            };
+            collectDependencies(requiredShapeNames);
+            // Collect interfaces that requiredShapeNames implement
+            const interfaceNames = new Set();
+            const requiredShapes = mapSet(requiredShapeNames, (shapeName) => newSchema.shapes[shapeName] ?? remoteShapeMap[shapeName]);
+            for (const shape of requiredShapes) {
+                if (shape?.interfaces) {
+                    addAll(interfaceNames, interfacesToShapeNames(projectSchema, shape.interfaces));
+                }
+            }
+            // Collect implementations for interfaces in requiredShapeNames
+            const implementationNames = new Set();
+            const implementations = getImplementationShapeNameMap({
+                ...newSchema.shapes,
+                ...remoteShapeMap
+            });
+            for (const shape of requiredShapes) {
+                if (isInterfaceShape(shape) && implementations[shape.name]) {
+                    addAll(implementationNames, implementations[shape.name]);
+                }
+            }
+            // Collect the dependencies for the interfaces and implementations
+            collectDependencies(interfaceNames);
+            collectDependencies(implementationNames);
+            addAll(requiredShapeNames, interfaceNames);
+            addAll(requiredShapeNames, implementationNames);
+            // Populate a ShapeMap with the remote shapes we've gathered
+            // A combined context which prefers remote shapes for use when merging/inlining
+            const mergingContext = {
+                services: newSchema.services,
+                shapes: { ...newSchema.shapes, ...remoteShapeMap }
+            };
+            for (const name of requiredShapeNames) {
+                const localShape = newSchema.shapes[name];
+                const remoteShape = remoteShapeMap[name];
+                if (localShape && remoteShape && schemaExtendsShape(mergingContext, name, localShape.schema)) {
+                    // Merge and inline combined shape when a local shape extends a remote shape
+                    newShapeMap[name] = {
+                        ...localShape,
+                        schema: dereferenceObjectSchema(mergingContext, newSchema.shapes[name].schema)
+                    };
+                }
+                else if (localShape ?? remoteShape) {
+                    newShapeMap[name] = localShape ?? remoteShape;
+                }
+            }
+        }
+        // Assign remote shapes to the new schema, mutating the new schema
+        Object.assign(newSchema.shapes, pruneUnusedInterfaces(newSchema, newShapeMap));
+    }
+    return newSchema;
+}

package/dist/services/__tests__/services.test.d.ts

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

package/dist/services/__tests__/services.test.js

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it, test, vi } from 'vitest';
+import { createMockSchema, createMockServiceConfig } from "../../mocks.js";
+import { prepareServiceUpdate } from "../services.js";
+import { getResolverServices, isMissingAuth } from "../util.js";
+beforeEach(vi.clearAllMocks);
+describe('prepareServiceUpdate', () => {
+    const serviceKey = 'mock-service';
+    const encryptedAuthentication = 'encrypted-token';
+    const serviceConfig = createMockServiceConfig(serviceKey);
+    const storedServiceConfig = {
+        ...serviceConfig,
+        authentication: encryptedAuthentication
+    };
+    const { authentication } = serviceConfig;
+    const projectSchema = createMockSchema('mock-schema', {
+        services: {
+            [serviceKey]: storedServiceConfig
+        }
+    });
+    const encryptFn = vi.fn(() => encryptedAuthentication);
+    const decryptFn = vi.fn(() => authentication);
+    it('prepares an update', async () => {
+        const serviceUpdate = {
+            title: 'foo',
+            authenticationType: 'bearer',
+            authentication: {
+                token: 'updated'
+            }
+        };
+        const result = prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey);
+        expect(encryptFn).toHaveBeenCalledWith({
+            ...authentication,
+            token: 'updated'
+        });
+        expect(result).toEqual({ ...storedServiceConfig, title: 'foo' });
+    });
+    it('can proceed with a full object, and nothing stored', async () => {
+        const result = prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceConfig, 'random');
+        expect(encryptFn).toHaveBeenCalledWith(authentication);
+        expect(result).toEqual(storedServiceConfig);
+    });
+    it('clears the authentication property when a null sentinel is sent', async () => {
+        const serviceUpdate = {
+            authenticationType: 'bearer',
+            authentication: null
+        };
+        const result = prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey);
+        expect(encryptFn).toHaveBeenCalledTimes(0);
+        expect(result).toEqual({
+            ...storedServiceConfig,
+            authentication: undefined
+        });
+    });
+    it('throws a validation error on invalid authentication properties', async () => {
+        const serviceUpdate = {
+            title: 'foo',
+            authenticationType: 'bearer',
+            authentication: {
+                bogus: 'bogus-property'
+            }
+        };
+        expect(() => prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey)).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: ServiceConfig was invalid]');
+    });
+    it('throws a validation error when the envelopes authenticationType changes', async () => {
+        const serviceUpdate = {
+            title: 'foo',
+            authenticationType: 'basic'
+        };
+        expect(() => prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey)).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: ServiceConfig was invalid]');
+    });
+});
+describe('getResolverServices', () => {
+    test('works for basic resolvers', () => {
+        expect(getResolverServices({
+            name: 'graphql:query',
+            service: 'foo',
+            fieldName: 'foo'
+        })).toEqual(['foo']);
+    });
+    test('works for compose resolvers', () => {
+        expect(getResolverServices({
+            compose: [
+                {
+                    name: 'graphql:query',
+                    service: 'a',
+                    fieldName: 'a'
+                },
+                {
+                    name: 'graphql:query',
+                    service: 'b',
+                    fieldName: 'b'
+                },
+                {
+                    name: 'graphql:query',
+                    service: 'c',
+                    fieldName: 'c'
+                },
+                {
+                    name: 'graphql:query',
+                    service: 'a',
+                    fieldName: 'a'
+                }
+            ]
+        })).toEqual(['a', 'b', 'c']);
+    });
+});
+test('isMissingAuth', () => {
+    expect(isMissingAuth({ authenticationType: 'none' })).toBe(false);
+    expect(isMissingAuth({ authenticationType: 'basic' })).toBe(true);
+    expect(
+    // @ts-expect-error for the sake of testing js runtime usage
+    isMissingAuth({ authenticationType: 'oauth2Bearer', authentication: {} })).toBe(true);
+});

package/dist/services/services.d.ts

@@ -0,0 +1,31 @@
+import type { Overwrite } from '@takeshape/util';
+import { SERVICE_OBJECT_PATTERN_NAME } from '../constants.ts';
+import type { ProjectSchemaJSON, ServiceConfig, ServiceConfigJSON, ServiceMapJSON, ShapeJSON } from '../project-schema/index.ts';
+import type { PatternGenerator, ServiceConfigUpdate, ServiceInfo, ServiceMap } from '../types/types.ts';
+import type { DecryptFn, EncryptFn } from './types.ts';
+/**
+ * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
+ * authentication object decrypted.
+ */
+export declare function decryptServiceConfig(decryptFn: DecryptFn, storedServiceConfig: ServiceConfigJSON): ServiceConfig;
+/**
+ * Given a `ServiceMapJSON` returns a usable `ServiceMap` with all the
+ * authentication objects decrypted.
+ */
+export declare function decryptServiceMap(decryptFn: DecryptFn, ServiceMapJSON: ServiceMapJSON): Promise<ServiceMap>;
+/**
+ * Validates a `ServiceConfig` validator based on the JSON-schema.
+ */
+export declare function validateServiceConfig(maybeServiceConfig: unknown): ServiceConfigJSON;
+/**
+ * Prepare a `ServiceConfig` object update, validating the overall structure
+ * and encrypting the `ServiceAuthentication` object.
+ */
+export declare function prepareServiceUpdate(encryptFn: EncryptFn, decryptFn: DecryptFn, projectSchema: ProjectSchemaJSON, serviceConfigUpdate: ServiceConfigUpdate, serviceKey: string): ServiceConfigJSON;
+export type ServiceInfoWithServiceObject = Overwrite<ServiceInfo, {
+    generators: {
+        [SERVICE_OBJECT_PATTERN_NAME]: PatternGenerator;
+    };
+}>;
+export declare function getServiceObjectFields(projectSchema: ProjectSchemaJSON, shape: ShapeJSON, provider: string): ServiceInfoWithServiceObject[];
+export declare function getServiceInfo(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): Record<string, ServiceInfo[]>;

package/dist/services/services.js

@@ -0,0 +1,145 @@
+import { SchemaValidationError } from '@takeshape/errors';
+import { createAjv } from '@takeshape/json-schema';
+import { mergeWithArrayMerge } from '@takeshape/util';
+import isEqual from 'lodash/isEqual.js';
+import isNull from 'lodash/isNull.js';
+import { SERVICE_OBJECT_PATTERN_NAME } from "../constants.js";
+import { createSchemaPropertyList, getGeneratorVersion, getServiceIdFieldName, getShapeDependencies, pathBetween } from "../schema-util.js";
+import { latestSchemaJson } from "../schemas/index.js";
+import { isEncryptedServiceConfig, isServiceAuthentication, isServiceResolver } from "../types/utils.js";
+import { formatError } from "../validate/errors.js";
+import { getStoredServiceConfig } from "./util.js";
+/**
+ * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
+ * authentication object decrypted.
+ */
+export function decryptServiceConfig(decryptFn, storedServiceConfig) {
+    let authentication;
+    if (isEncryptedServiceConfig(storedServiceConfig)) {
+        const decrypted = decryptFn(storedServiceConfig.authentication);
+        if (isServiceAuthentication(decrypted)) {
+            authentication = decrypted;
+        }
+    }
+    return {
+        ...storedServiceConfig,
+        authentication
+    };
+}
+/**
+ * Given a `ServiceMapJSON` returns a usable `ServiceMap` with all the
+ * authentication objects decrypted.
+ */
+export async function decryptServiceMap(decryptFn, ServiceMapJSON) {
+    return Object.entries(ServiceMapJSON).reduce((result, [serviceKey, serviceConfig]) => {
+        return result.set(serviceKey, decryptServiceConfig(decryptFn, serviceConfig));
+    }, new Map());
+}
+function createServiceConfigValidator() {
+    const validator = createAjv();
+    const { serviceConfig, ...definitions } = latestSchemaJson.definitions;
+    return validator.compile({
+        $id: 'ServiceConfig',
+        definitions,
+        ...serviceConfig
+    });
+}
+const serviceConfigValidator = createServiceConfigValidator();
+/**
+ * Validates a `ServiceConfig` validator based on the JSON-schema.
+ */
+export function validateServiceConfig(maybeServiceConfig) {
+    if (serviceConfigValidator(maybeServiceConfig)) {
+        return maybeServiceConfig;
+    }
+    throw new SchemaValidationError('ServiceConfig was invalid', serviceConfigValidator.errors?.map(formatError));
+}
+/**
+ * Prepare a `ServiceConfig` object update, validating the overall structure
+ * and encrypting the `ServiceAuthentication` object.
+ */
+export function prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceConfigUpdate, serviceKey) {
+    const storedServiceConfig = getStoredServiceConfig(projectSchema, serviceKey);
+    let newServiceConfig = serviceConfigUpdate;
+    if (storedServiceConfig) {
+        const existingServiceConfig = decryptServiceConfig(decryptFn, storedServiceConfig);
+        newServiceConfig = mergeWithArrayMerge(existingServiceConfig, serviceConfigUpdate);
+    }
+    const { authentication, authenticationType } = newServiceConfig;
+    if (authenticationType === 'none' || isNull(authentication)) {
+        // biome-ignore lint/performance/noDelete: Property presence may matter here
+        delete newServiceConfig.authentication;
+    }
+    else if (authentication !== undefined) {
+        // Add the discriminator to the authentication object, set authenticationType
+        // to ensure the update is correct for the auth type.
+        newServiceConfig.authentication = {
+            ...authentication,
+            type: authenticationType
+        };
+    }
+    validateServiceConfig(newServiceConfig);
+    let serviceConfig;
+    if (newServiceConfig.authentication) {
+        serviceConfig = {
+            ...newServiceConfig,
+            authentication: encryptFn(newServiceConfig.authentication)
+        };
+    }
+    else {
+        serviceConfig = newServiceConfig;
+    }
+    return serviceConfig;
+}
+export function getServiceObjectFields(projectSchema, shape, provider) {
+    return (getServiceInfo(projectSchema, shape)[provider] ?? []).filter((serviceInfo) => serviceInfo.generators[SERVICE_OBJECT_PATTERN_NAME]);
+}
+// Returns info for all services found in shape, keyed by provider
+export function getServiceInfo(projectSchema, shape) {
+    const result = {};
+    // Get inline dependencies by not following refs with @resolver
+    const inlineDepShapes = getShapeDependencies(projectSchema, shape, (prop) => !prop['@resolver']).map((name) => projectSchema.shapes[name]);
+    const shapesToCheck = [shape, ...inlineDepShapes];
+    for (const thisShape of shapesToCheck) {
+        // biome-ignore lint/complexity/noForEach: Types for createSchemaPropertyList do not include the iterator
+        createSchemaPropertyList(projectSchema, thisShape).forEach(([key, value]) => {
+            const resolver = value['@resolver'];
+            if (!isServiceResolver(resolver)) {
+                return;
+            }
+            const serviceConfig = getStoredServiceConfig(projectSchema, resolver.service);
+            if (!serviceConfig) {
+                return;
+            }
+            const { provider } = serviceConfig;
+            const generators = {};
+            const tag = value['@tag'];
+            if (tag?.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
+                const idFieldName = getServiceIdFieldName(key);
+                const version = tag.substr(Number(tag.lastIndexOf(':')) + 1);
+                generators[SERVICE_OBJECT_PATTERN_NAME] = {
+                    version,
+                    currentVersion: getGeneratorVersion(SERVICE_OBJECT_PATTERN_NAME),
+                    idFieldName,
+                    serviceObjectType: resolver.fieldName
+                };
+            }
+            const serviceInfo = {
+                service: resolver.service,
+                fieldName: key,
+                path: pathBetween(shape, thisShape, projectSchema),
+                generators
+            };
+            if (Array.isArray(result[provider])) {
+                // Dedupe service info
+                if (!result[provider].find((existingServiceInfo) => isEqual(existingServiceInfo, serviceInfo))) {
+                    result[provider].push(serviceInfo);
+                }
+            }
+            else {
+                result[provider] = [serviceInfo];
+            }
+        });
+    }
+    return result;
+}

package/dist/services/types.js

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

package/dist/services/util.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectSchemaJSON, Resolver, ServiceConfig, ServiceConfigJSON } from '../project-schema/index.ts';
+import type { ServiceKey } from '../types/types.ts';
+/**
+ * Get a service config from a project schema.
+ */
+export declare function getStoredServiceConfig(projectSchema: ProjectSchemaJSON, serviceKey: ServiceKey): ServiceConfigJSON | undefined;
+/**
+ * Get a `Map` keyed with all the service namespaces.
+ *
+ * @param context A partial project schema
+ *
+ * @returns A `Map` with namespaces as keys, and service keys as values.
+ */
+export declare function getServiceNamespaces(context: Pick<ProjectSchemaJSON, 'services'>): Map<string, string>;
+export declare function isMissingAuth(service: Pick<ServiceConfig | ServiceConfigJSON, 'authenticationType' | 'authentication'>): boolean;
+export declare function getResolverServices(resolver: Resolver): string[];

package/dist/taxonomies.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectSchemaJSON, ShapeJSON } from './project-schema/index.ts';
+export type TaxonomyField = {
+    name: string;
+    key?: string;
+};
+export type Taxonomy = {
+    shapeId: string;
+    field: TaxonomyField;
+};
+export declare function getFirstStringFieldV3(shape: ShapeJSON, projectSchema: ProjectSchemaJSON): {
+    name: string;
+    key?: string;
+} | null;
+export declare const getTaxonomyField: (shape: ShapeJSON, projectSchema: ProjectSchemaJSON) => TaxonomyField | null;
+export declare const getTaxonomies: (projectSchema: ProjectSchemaJSON) => Taxonomy[];

package/dist/taxonomies.js

@@ -0,0 +1,24 @@
+import { weakMemoize } from '@takeshape/util';
+import { createSchemaPropertyAccessor } from "./schema-util.js";
+export function getFirstStringFieldV3(shape, projectSchema) {
+    const forms = projectSchema.forms?.[shape.name];
+    if (!forms?.default) {
+        return null;
+    }
+    const schemaProperties = createSchemaPropertyAccessor(projectSchema, shape);
+    const { order } = forms.default;
+    const name = order.find((name) => schemaProperties.getValue(name)?.type === 'string');
+    return name ? { name, key: schemaProperties.getKey(name) } : null;
+}
+export const getTaxonomyField = weakMemoize((shape, projectSchema) => shape.model?.type === 'taxonomy' ? getFirstStringFieldV3(shape, projectSchema) : null);
+export const getTaxonomies = weakMemoize((projectSchema) => {
+    const { shapes } = projectSchema;
+    return Object.keys(shapes).reduce((result, shapeName) => {
+        const shape = shapes[shapeName];
+        const field = getTaxonomyField(shape, projectSchema);
+        if (field) {
+            result.push({ shapeId: shape.id, field });
+        }
+        return result;
+    }, []);
+});

package/dist/template-shapes/__tests__/index.test.d.ts

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

package/dist/template-shapes/__tests__/index.test.js

@@ -0,0 +1,40 @@
+import blogSchema from '@/examples/latest/blog-schema.json';
+import { describe, expect, test } from 'vitest';
+import { isValidTemplate, resolveTemplate } from "../index.js";
+describe('resolveTemplate', () => {
+    test('success', () => {
+        expect(resolveTemplate(blogSchema, 'TSGetArgs', 'Post')).toEqual({
+            dependencies: {
+                PostTSGetArgs: {
+                    id: 'PostTSGetArgs',
+                    name: 'PostTSGetArgs',
+                    schema: {
+                        properties: {
+                            _id: { type: 'string' },
+                            enableLocaleFallback: { default: true, type: 'boolean' },
+                            locale: { type: 'string' }
+                        },
+                        required: ['_id'],
+                        type: 'object'
+                    },
+                    title: 'PostTSGetArgs'
+                }
+            },
+            shapeName: 'PostTSGetArgs'
+        });
+    });
+    test('invalid template', () => {
+        expect(() => resolveTemplate(blogSchema, 'TSGetRekt', 'Post')).toThrowError('Invalid shape template TSGetRekt');
+    });
+    test('invalid shape', () => {
+        expect(() => resolveTemplate(blogSchema, 'TSGetArgs', 'Nerd')).toThrowError('Unknown shape "Nerd" in template "TSGetArgs"');
+    });
+});
+describe('isValidTemplate', () => {
+    test('yes', () => {
+        expect(isValidTemplate('TSGetArgs')).toEqual(true);
+    });
+    test('no', () => {
+        expect(isValidTemplate('TSGetBreakfast')).toEqual(false);
+    });
+});

package/dist/template-shapes/__tests__/names.test.d.ts

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

package/dist/template-shapes/__tests__/names.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { getOutputShapeName } from "../names.js";
+describe('getOutputShapeName', () => {
+    it('should remove "Input" suffix from the name', () => {
+        expect(getOutputShapeName('UserInput')).toBe('User');
+    });
+    it('should remove "PartialInput" suffix from the name', () => {
+        expect(getOutputShapeName('UserPartialInput')).toBe('User');
+    });
+    it('should not change the name if it does not have "Input" or "PartialInput" suffix', () => {
+        expect(getOutputShapeName('User')).toBe('User');
+    });
+    it('should not change the name if it has "Input" or "PartialInput" in the middle', () => {
+        expect(getOutputShapeName('InputUserPartial')).toBe('InputUserPartial');
+    });
+    it('should handle empty string', () => {
+        expect(getOutputShapeName('')).toBe('');
+    });
+});

package/dist/template-shapes/__tests__/templates.test.d.ts

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

package/dist/template-shapes/__tests__/templates.test.js

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import { createMockSchema } from "../../mocks.js";
+import { CreateArgs, DeleteArgs, DuplicateArgs, UpdateArgs } from "../templates.js";
+describe('getMutationArgs', () => {
+    const Mock = {
+        title: 'Mock',
+        name: 'Mock',
+        id: 'Mock',
+        schema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    '@input': {
+                        type: 'number'
+                    }
+                }
+            }
+        }
+    };
+    const projectSchema = createMockSchema('<project-id>', {
+        shapes: { Mock }
+    });
+    it('should substitute @input for the original field schema', () => {
+        const createResult = CreateArgs({ projectSchema }, Mock);
+        expect(createResult.dependencies.CreateMockInput.schema).toEqual({
+            type: 'object',
+            properties: {
+                title: {
+                    '@output': {
+                        type: 'string'
+                    },
+                    type: 'number'
+                }
+            }
+        });
+        const updateResult = UpdateArgs({ projectSchema }, Mock);
+        expect(updateResult.dependencies.UpdateMockInput.schema).toEqual({
+            type: 'object',
+            properties: {
+                _id: {
+                    type: 'string'
+                },
+                title: {
+                    '@output': {
+                        type: 'string'
+                    },
+                    type: 'number'
+                }
+            },
+            required: ['_id']
+        });
+        const duplicateResult = DuplicateArgs({ projectSchema }, Mock);
+        expect(duplicateResult.dependencies.DuplicateMockInput.schema).toEqual({
+            type: 'object',
+            properties: {
+                _id: {
+                    type: 'string'
+                },
+                title: {
+                    '@output': {
+                        type: 'string'
+                    },
+                    type: 'number'
+                }
+            },
+            required: ['_id']
+        });
+        const deleteResult = DeleteArgs({ projectSchema }, Mock);
+        expect(deleteResult.dependencies.DeleteMockInput.schema).toEqual({
+            type: 'object',
+            properties: {
+                _id: {
+                    type: 'string'
+                }
+            },
+            required: ['_id']
+        });
+    });
+});