@takeshape/schema 11.52.0 → 11.55.0

package/dist/__tests__/_examples.test.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_ENTITLEMENTS } from '@takeshape/util';
+import glob from 'glob';
+import pick from 'lodash/pick.js';
+import coerce from 'semver/functions/coerce.js';
+import compare from 'semver/functions/compare.js';
+import { describe, expect, test } from 'vitest';
+import { createMockSchema } from "../mocks.js";
+import { migrateToLatestProjectSchema } from "../project-schema/migrate.js";
+import { validateSchema, validateSchemaSyntax } from "../validate/validate.js";
+const examplesPath = path.join(__dirname, '../../examples');
+const readSchema = (filePath) => JSON.parse(fs.readFileSync(path.join(examplesPath, filePath), 'utf-8'));
+const writeSchema = (filePath, content) => fs.writeFileSync(path.join(examplesPath, filePath), JSON.stringify(content, null, 2), { encoding: 'utf8' });
+const sourceFiles = glob.sync('source/**/*.json', { cwd: examplesPath });
+const sources = sourceFiles
+    .map((sourceFilePath) => {
+    const schema = readSchema(sourceFilePath);
+    return [coerce(schema.schemaVersion ?? '1')?.version, path.basename(sourceFilePath), schema, sourceFilePath];
+})
+    .sort(([a], [b]) => compare(a, b));
+const migrationContext = {
+    encryptFn() {
+        return 'abc';
+    },
+    decryptFn() {
+        return { token: 'xyz' };
+    },
+    async generateDataKeyFn() {
+        return 'supersecret';
+    }
+};
+function isLayerPath(pathStr) {
+    return pathStr.includes('/layers/');
+}
+function layerToProjectSchema(layerSchema) {
+    return createMockSchema('project-id', layerSchema);
+}
+async function migrateLayer(schema) {
+    return pick(await migrateToLatestProjectSchema(migrationContext, layerToProjectSchema(schema)), [
+        'shapes',
+        'queries',
+        'mutations',
+        'schemaVersion'
+    ]);
+}
+describe.each(sources)('%s - %s', (_, fileName, schema, sourceFilePath) => {
+    const isLayer = isLayerPath(sourceFilePath);
+    const latestFilePath = isLayer ? `latest/layers/${fileName}` : `latest/${fileName}`;
+    test('validate source schema', () => {
+        const projectSchema = isLayer ? layerToProjectSchema(schema) : schema;
+        const { errors } = validateSchemaSyntax(projectSchema);
+        expect(errors).toBe(undefined);
+    });
+    test('migrate source schema to latest', async () => {
+        const migratedSchema = await (isLayer
+            ? migrateLayer(schema)
+            : migrateToLatestProjectSchema(migrationContext, schema));
+        // @ts-expect-error
+        if (expect.getState().snapshotState._updateSnapshot === 'all') {
+            console.info(`Updating examples/latest/${fileName}`);
+            writeSchema(latestFilePath, migratedSchema);
+        }
+        else {
+            const migratedSchemaSnapshot = readSchema(latestFilePath);
+            expect(migratedSchema).toEqual(migratedSchemaSnapshot);
+        }
+    });
+    test('validate migrated schema', async () => {
+        const migratedSchemaSnapshot = readSchema(latestFilePath);
+        const projectSchema = isLayer ? layerToProjectSchema(migratedSchemaSnapshot) : migratedSchemaSnapshot;
+        const { errors } = isLayer
+            ? validateSchemaSyntax(projectSchema)
+            : await validateSchema({ entitlements: DEFAULT_ENTITLEMENTS }, projectSchema);
+        expect(errors).toBe(undefined);
+    });
+});

package/dist/__tests__/agents.test.js

@@ -0,0 +1,163 @@
+import agentSchemaJSON from '@takeshape/schema/examples/latest/agent-schema.json';
+import blogSchemaJSON from '@takeshape/schema/examples/latest/blog-schema.json';
+import { describe, expect, test } from 'vitest';
+import { addAiQueries, createArgs, getAgentEndStates, getAgentEndTransitions, getInspectAgentSessionQueryName } from "../agents.js";
+const agentSchema = agentSchemaJSON;
+const blogSchema = blogSchemaJSON;
+const findDogColor = agentSchema['ai-experimental'].agents.findDogColor;
+describe('getAgentEndTransitions', () => {
+    test('chat', () => {
+        expect(getAgentEndTransitions(agentSchema['ai-experimental'].agents.chat)).toEqual([
+            {
+                originStateId: '3pjuyB47X',
+                type: 'done'
+            }
+        ]);
+    });
+    test('findDogColor', () => {
+        expect(getAgentEndTransitions(agentSchema['ai-experimental'].agents.findDogColor)).toEqual([
+            {
+                originStateId: 'ddd',
+                type: 'done'
+            },
+            {
+                originStateId: 'eee',
+                type: 'done'
+            }
+        ]);
+    });
+});
+describe('getAgentEndStates', () => {
+    test('chat', () => {
+        expect(getAgentEndStates(agentSchema['ai-experimental'].agents.chat)).toEqual(new Set(['3pjuyB47X']));
+    });
+    test('findDogColor', () => {
+        expect(getAgentEndStates(agentSchema['ai-experimental'].agents.findDogColor)).toEqual(new Set(['ddd', 'eee']));
+    });
+});
+describe('getInspectAgentSessionQueryName', () => {
+    test('it works', () => {
+        expect(getInspectAgentSessionQueryName('chatWithGreg')).toEqual('inspectChatWithGreg');
+    });
+});
+describe('addAiQueries', () => {
+    const newSchema = addAiQueries(agentSchema);
+    test('chat', () => {
+        expect(newSchema.mutations.chat).toEqual({
+            args: {
+                properties: {
+                    input: {
+                        type: 'string',
+                        description: 'Input text for the agent'
+                    },
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to continue existing session with this agent'
+                    }
+                },
+                required: ['input'],
+                type: 'object'
+            },
+            resolver: {
+                agentName: 'chat',
+                name: 'ai:runAgent'
+            },
+            shape: 'TSChatResponse'
+        });
+        expect(newSchema.queries.inspectChat).toEqual({
+            args: {
+                properties: {
+                    sessionId: {
+                        type: 'string'
+                    }
+                },
+                required: ['sessionId'],
+                type: 'object'
+            },
+            description: 'Inspect a session for the chat agent',
+            resolver: {
+                agentName: 'chat',
+                name: 'ai:inspectAgentSession'
+            },
+            shape: 'TSAgentSession'
+        });
+    });
+    test('findDogColor', () => {
+        expect(newSchema.mutations.findDogColor).toEqual({
+            args: {
+                properties: {
+                    input: {
+                        type: 'string'
+                    }
+                },
+                required: ['input'],
+                type: 'object'
+            },
+            description: "AI Agent finds a dog's color based on its name",
+            resolver: {
+                agentName: 'findDogColor',
+                name: 'ai:runAgent'
+            },
+            shape: 'string'
+        });
+        expect(newSchema.queries.inspectFindDogColor).toEqual(undefined);
+    });
+    test('no agents', () => {
+        expect(Object.values(addAiQueries(blogSchema).queries).length).toEqual(Object.values(blogSchema.queries).length);
+    });
+});
+describe('createArgs', () => {
+    test('deals with duplicates', () => {
+        expect(createArgs({
+            ...findDogColor,
+            api: {
+                type: 'generate',
+                arguments: [
+                    {
+                        argName: 'foo',
+                        argType: 'string'
+                    },
+                    {
+                        argName: 'foo',
+                        argType: 'number'
+                    }
+                ]
+            }
+        })).toEqual({
+            properties: {
+                foo: {
+                    type: 'string'
+                }
+            },
+            required: [],
+            type: 'object'
+        });
+    });
+    test('overwrites chat default args', () => {
+        expect(createArgs({
+            ...findDogColor,
+            api: {
+                type: 'chat',
+                arguments: [
+                    {
+                        argName: 'input',
+                        argType: 'number'
+                    }
+                ]
+            }
+        })).toEqual({
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'Input text for the agent'
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID to continue existing session with this agent'
+                }
+            },
+            required: ['input'],
+            type: 'object'
+        });
+    });
+});

package/dist/__tests__/api-version.test.js

@@ -0,0 +1,24 @@
+import gte from 'semver/functions/gte.js';
+import { expect, test } from 'vitest';
+import { createVersionPredicate, whereClauseEnabled, workflowsEnabled } from "../api-version.js";
+import { CURRENT_API_VERSION, LEGACY_API_VERSION } from "../versions.js";
+test('workflowsEnabled - new api', () => {
+    expect(workflowsEnabled(CURRENT_API_VERSION)).toBe(true);
+});
+test('workflowsEnabled - legacy api', () => {
+    expect(workflowsEnabled(LEGACY_API_VERSION)).toBe(false);
+});
+test('whereClauseEnabled - new api', () => {
+    expect(whereClauseEnabled(CURRENT_API_VERSION)).toBe(true);
+});
+test('whereClauseEnabled - legacy api', () => {
+    expect(whereClauseEnabled(LEGACY_API_VERSION)).toBe(false);
+});
+test('createVersionPredicate - throw feature version coercion error', () => {
+    const errorPredicate = () => createVersionPredicate('bogus', gte)('2');
+    expect(errorPredicate).toThrowError('Could not create predicate version "bogus" is not valid');
+});
+test('createVersionPredicate - throw api version coercion error', () => {
+    const errorPredicate = () => createVersionPredicate('2', gte)('bogus');
+    expect(errorPredicate).toThrowError('Version "bogus" is not valid and could not be coerced');
+});

package/dist/__tests__/builtin-schema.test.js

@@ -0,0 +1,18 @@
+import { expect, test } from 'vitest';
+import { getAssetS3Path, isAsset, setAssetS3Path } from "../builtin-schema.js";
+test('getAssetS3Path', () => {
+    expect(getAssetS3Path({
+        _id: 'asset-id',
+        _contentTypeId: 'ASSET',
+        Hk6FQuz5: 'woo.jpg'
+    })).toBe('woo.jpg');
+});
+test('setAssetS3Path', () => {
+    const content = { _id: 'asset-id', _contentTypeId: 'ASSET' };
+    setAssetS3Path(content, 'woo.jpg');
+    expect(content.Hk6FQuz5).toBe('woo.jpg');
+});
+test('isAsset', () => {
+    expect(isAsset({ _id: 'asset-id', _contentTypeId: 'ASSET', Hk6FQuz5: 'woo.jpg' })).toBe(true);
+    expect(isAsset({ _id: 'asset-id', _contentTypeId: 'SITE' })).toBe(false);
+});

package/dist/__tests__/content-schema-transform.test.d.ts

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