@takeshape/schema 11.40.0 → 11.40.3

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

@@ -0,0 +1,119 @@
+import { deepClone } from "@takeshape/util";
+import upperFirst from "lodash/upperFirst.js";
+import set from "lodash/fp/set.js";
+import unset from "lodash/fp/unset.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";
+import { SERVICE_OBJECT_PATTERN_NAME } from "../../constants.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];
+        delete propConfig.properties;
+        delete propConfig.order;
+        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"]) {
+                    // eslint-disable-next-line max-depth
+                    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
+        // eslint-disable-next-line no-console
+        console.log(`v3.34.0 migration warning: Failed to normalize forms`, e.message);
+    }
+    try {
+        normalized = migrateInterfaceShapes(normalized);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.log(`v3.34.0 migration warning: Failed to migrate interface shapes`, e.message);
+    }
+    return {
+        ...normalized,
+        schemaVersion: "3.34.0"
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.35.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.35.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.36.0.js

@@ -0,0 +1,22 @@
+import mapValues from 'lodash/mapValues.js';
+const migrate = async (_, projectSchema) => {
+    const result = {
+        ...projectSchema,
+        schemaVersion: '3.36.0'
+    };
+    result.services &&= mapValues(result.services, config => {
+        // Add transformVersion to OpenAPI services so we can preserve the legacy behavior
+        if (config.serviceType === 'openapi') {
+            return {
+                ...config,
+                options: {
+                    ...config.options,
+                    transformVersion: '1.0.0'
+                }
+            };
+        }
+        return config;
+    });
+    return result;
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.37.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.37.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.38.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.38.0'
+    };
+};
+export default migrate;

package/dist/esm/src/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.
+     */
+    Object.values(projectSchema.services ?? {}).forEach(serviceConfig => {
+        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
+                            }
+                        };
+                        delete serviceConfig.options.shopDomain;
+                    }
+                    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
+                            }
+                        };
+                        delete serviceConfig.options.storeId;
+                    }
+                    authentication.params = authentication.params.filter(param => param.name !== "store");
+                }
+                serviceConfig.authentication = encryptFn(authentication);
+            }
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: "3.39.0"
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.4.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.4.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.40.0.js

@@ -0,0 +1,26 @@
+import mapValues from 'lodash/mapValues.js';
+const migrate = async (_, projectSchema) => {
+    const newShapes = mapValues(projectSchema.shapes, shape => {
+        // Set includeDeprecated to true for shapes to preserve behavior when indexing shapes by maxDepth
+        if (shape.cache?.fragment?.maxDepth !== undefined) {
+            const newShape = {
+                ...shape,
+                cache: {
+                    ...shape.cache,
+                    fragment: {
+                        ...shape.cache.fragment,
+                        includeDeprecated: true
+                    }
+                }
+            };
+            return newShape;
+        }
+        return shape;
+    });
+    return {
+        ...projectSchema,
+        shapes: newShapes,
+        schemaVersion: '3.40.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.41.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.41.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.42.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.42.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.43.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.43.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.44.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.44.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.45.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.45.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.46.0.js

@@ -0,0 +1,35 @@
+import { isRecord, visit } from '@takeshape/util';
+// copied in case we update these in the latest version
+function isBasicResolver(resolver) {
+    return isRecord(resolver) && typeof resolver.name === 'string';
+}
+function isComposeResolver(resolver) {
+    return Boolean(isRecord(resolver) &&
+        Array.isArray(resolver.compose) &&
+        resolver.compose.length &&
+        resolver.compose.every(isBasicResolver));
+}
+function renameResolver(resolver) {
+    // Replace ai:generateText with ai:chat unless history was disabled
+    if (resolver.name === 'ai:generateText' && (resolver.options?.history ?? true)) {
+        resolver.name = 'ai:chat';
+    }
+}
+const migrate = async (_, projectSchema) => {
+    /**
+     * Function will visit each resolver in the schema and mutate them.
+     */
+    visit(projectSchema, ['resolver', '@resolver'], maybeResolver => {
+        if (isComposeResolver(maybeResolver)) {
+            maybeResolver.compose.forEach(renameResolver);
+        }
+        else if (isBasicResolver(maybeResolver)) {
+            renameResolver(maybeResolver);
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.46.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.47.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.47.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.48.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.48.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.49.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.49.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.5.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.5.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.5.1.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.5.1'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.50.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.50.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.6.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.6.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.7.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.7.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.8.0.js

@@ -0,0 +1,10 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * No migration needed all changes are backwards compatible.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.8.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/to/v3.9.0.js

@@ -0,0 +1,79 @@
+import { visit } from '@takeshape/util';
+import omit from 'lodash/omit.js';
+import isEmpty from 'lodash/isEmpty.js';
+function omitOptions(resolver, names) {
+    if (resolver.options) {
+        const newOptions = omit(resolver.options, names);
+        if (isEmpty(newOptions)) {
+            delete resolver.options;
+        }
+        else {
+            resolver.options = newOptions;
+        }
+    }
+}
+const migrate = async (_, projectSchema) => {
+    /**
+     * Resolver props that are guaranteed in this version, and dependent on the
+     * resolver type. Ensure they exist.
+     */
+    const ensureResolverOptions = (resolver) => {
+        if (resolver.name.startsWith('takeshape')) {
+            if (!resolver.shapeName) {
+                resolver.shapeName =
+                    resolver.options?.model ?? resolver.options?.indexedShape ?? '';
+                omitOptions(resolver, ['model', 'indexedShape']);
+            }
+        }
+        if (resolver.name.startsWith('graphql')) {
+            if (!resolver.fieldName) {
+                resolver.fieldName = resolver.options?.fieldName ?? '';
+                omitOptions(resolver, ['fieldName']);
+            }
+        }
+        if (resolver.name.startsWith('awsLambda')) {
+            if (!resolver.functionName) {
+                resolver.functionName = resolver.options?.functionName ?? '';
+                omitOptions(resolver, ['functionName']);
+            }
+        }
+        if (resolver.name.startsWith('rest')) {
+            if (!resolver.path) {
+                if (resolver.pathParams) {
+                    resolver.path = {
+                        ...resolver.pathParams,
+                        serialize: {
+                            ...resolver.pathParams.serialize,
+                            template: resolver.options?.path
+                        }
+                    };
+                }
+                else {
+                    resolver.path = resolver.options?.path ?? '';
+                }
+                omitOptions(resolver, ['path']);
+            }
+        }
+        /**
+         * `resolver.name` was previously validated with app code and v3.9.0
+         * enumerates the previous validation, making this assertion safe.
+         */
+        return resolver;
+    };
+    /**
+     * Function will visit each resolver in the schema and mutate them.
+     */
+    visit(projectSchema, ['resolver', '@resolver'], resolver => {
+        if (resolver.compose) {
+            resolver.compose.forEach(ensureResolverOptions);
+        }
+        else {
+            ensureResolverOptions(resolver);
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.9.0'
+    };
+};
+export default migrate;

package/dist/esm/src/migration/types.js

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

package/dist/esm/src/migration/utils.js

@@ -0,0 +1,6 @@
+export function formatDate(timestamp) {
+    return (timestamp ? new Date(timestamp) : new Date()).toISOString();
+}
+export function normalizeSchemaVersion(version) {
+    return version ?? '1';
+}

package/dist/esm/src/mocks.js

@@ -0,0 +1,58 @@
+import { pascalCase } from "@takeshape/util";
+import { emptySchema, applyDefaultsToSchema } 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 }
+    };
+}