@takeshape/schema 12.1.1 → 12.1.5

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

@@ -0,0 +1,194 @@
+import { deepClone, pascalCase } from '@takeshape/util';
+import isObject from 'lodash/isObject.js';
+import isString from 'lodash/isString.js';
+import isUndefined from 'lodash/isUndefined.js';
+import pReduce from 'p-reduce';
+import { isAnyServiceConfig } from "../../types/utils.js";
+/**
+ * `graphql:my-key` `my-key`
+ */
+function parseV3ServiceStr(service) {
+    const parts = service.split(':');
+    return {
+        provider: parts.length > 1 ? parts[0] : undefined,
+        id: parts.length > 1 ? parts[1] : parts[0]
+    };
+}
+/**
+ * Ensures a consistent service config, inluding updating the service
+ * authentication object.
+ */
+function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
+    if (isAnyServiceConfig(serviceConfig)) {
+        if (isString(serviceConfig.authentication) || isUndefined(serviceConfig.authentication)) {
+            return serviceConfig;
+        }
+        return serviceConfig;
+    }
+    const { auth } = serviceConfig;
+    const serviceParams = serviceConfig.params || {};
+    let { provider: serviceKeyProvider, id: serviceKeyId } = parseV3ServiceStr(serviceKey);
+    const authType = serviceParams.authType || undefined;
+    const title = serviceParams.name || serviceKeyId;
+    if (serviceKeyId === 'vercel') {
+        serviceKeyProvider = 'vercel';
+    }
+    else if (serviceKeyId === 'netlify') {
+        serviceKeyProvider = 'netlify';
+    }
+    // Example schemas had this in params, which are untyped, so adding here just in case
+    if (serviceParams.type === 'rest') {
+        serviceKeyProvider = 'rest';
+    }
+    else if (serviceParams.type === 'graphql' && serviceKeyProvider !== 'shopify') {
+        serviceKeyProvider = 'graphql';
+    }
+    let provider;
+    let authenticationType;
+    let serviceType;
+    let namespace;
+    if (serviceKeyProvider === 'shopify') {
+        provider = 'shopify';
+        authenticationType = 'oauth2Bearer';
+        serviceType = 'graphql';
+        namespace = serviceParams.namespace ?? 'Shopify';
+    }
+    else if (serviceKeyProvider === 'takeshape') {
+        provider = 'takeshape';
+        authenticationType = 'none';
+        serviceType = 'takeshape';
+        namespace = serviceParams.namespace ?? 'TakeShape';
+    }
+    else if (serviceKeyProvider === 'bigcommerce') {
+        provider = 'bigcommerce';
+        authenticationType = 'bearer';
+        serviceType = 'graphql';
+        namespace = serviceParams.namespace ?? 'BigCommerce';
+    }
+    else if (serviceKeyProvider === 'rest') {
+        provider = 'generic';
+        authenticationType = mapAuthType(authType, auth);
+        serviceType = 'rest';
+        namespace = serviceParams.namespace ?? pascalCase(title);
+    }
+    else if (serviceKeyProvider === 'graphql') {
+        provider = 'generic';
+        authenticationType = mapAuthType(authType, auth);
+        serviceType = 'graphql';
+        namespace = serviceParams.namespace ?? pascalCase(title);
+    }
+    else if (serviceKeyProvider === 'vercel') {
+        provider = 'vercel';
+        authenticationType = 'oauth2Bearer';
+        serviceType = 'deployment';
+    }
+    else if (serviceKeyProvider === 'netlify') {
+        provider = 'netlify';
+        authenticationType = 'oauth2Bearer';
+        serviceType = 'deployment';
+    }
+    else {
+        provider = 'generic';
+        authenticationType = mapAuthType(authType, auth);
+        serviceType = 'unknown';
+        namespace = serviceParams.namespace ?? pascalCase(title);
+    }
+    const updatedServiceConfig = {
+        title,
+        id: serviceKey,
+        provider,
+        namespace,
+        serviceType,
+        authenticationType,
+        options: {
+            ...serviceParams
+        }
+    };
+    if (serviceConfig.auth && isObject(serviceConfig.auth)) {
+        const authentication = updateServiceAuthentication(updatedServiceConfig.authenticationType, serviceConfig.auth, serviceParams);
+        return {
+            ...updatedServiceConfig,
+            authentication
+        };
+    }
+    return updatedServiceConfig;
+}
+/**
+ * V1/V3 unencrypted `auth` -> V3.1 `authentication
+ */
+function updateServiceAuthentication(authenticationType, legacyAuth, legacyParams) {
+    if (authenticationType === 'oauth2Bearer') {
+        return {
+            token: legacyAuth.accessToken,
+            scope: legacyAuth.scope,
+            header: legacyParams.authHeader
+        };
+    }
+    if (authenticationType === 'searchParams' && legacyParams.authProp) {
+        return [
+            {
+                name: legacyParams.authProp,
+                value: legacyAuth.accessToken
+            }
+        ];
+    }
+    if (authenticationType === 'basic') {
+        const [username, password] = Buffer.from(legacyAuth.accessToken, 'base64').toString('utf-8').split(':');
+        return {
+            username,
+            password
+        };
+    }
+    if (authenticationType === 'bearer') {
+        return {
+            token: legacyAuth.accessToken,
+            header: legacyParams.authHeader
+        };
+    }
+}
+function mapAuthType(authType, auth) {
+    if (authType === 'none') {
+        return 'none';
+    }
+    if (authType === 'searchParams') {
+        return 'searchParams';
+    }
+    if (authType === 'bearer') {
+        return 'bearer';
+    }
+    if (authType === 'bearer') {
+        return 'basic';
+    }
+    if (!auth) {
+        return 'none';
+    }
+    if (auth) {
+        return 'bearer';
+    }
+    return 'unknown';
+}
+const migrate = async (context, projectSchema) => {
+    const { encryptFn, decryptFn } = context;
+    let services;
+    /**
+     * Services can only be migrated if a dataKey is present, otherwise they will need to be discarded.
+     */
+    if (projectSchema.services) {
+        services = await pReduce(Object.entries(projectSchema.services), async (serviceMap, [serviceKey, serviceConfig]) => {
+            const auth = serviceConfig.auth && decryptFn(serviceConfig.auth);
+            const updatedServiceConfig = updateServiceConfigV3ToV3_1({ ...serviceConfig, auth }, serviceKey);
+            const authentication = updatedServiceConfig?.authentication;
+            serviceMap[serviceKey] = {
+                ...updatedServiceConfig,
+                authentication: authentication && isObject(authentication) ? encryptFn(authentication) : authentication
+            };
+            return serviceMap;
+        }, {});
+    }
+    return deepClone({
+        ...projectSchema,
+        services,
+        schemaVersion: '3.1.0'
+    });
+};
+export default migrate;

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

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

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

@@ -0,0 +1,67 @@
+import set from 'lodash/fp/set.js';
+import mapValues from 'lodash/mapValues.js';
+function $refToPath(ref) {
+    return ref.substr(2).split('/');
+}
+function $refToShapeName(ref) {
+    return $refToPath(ref)[1];
+}
+function findServiceIdForNamespace(projectSchema, namespace) {
+    if (projectSchema.services) {
+        for (const [serviceId, service] of Object.entries(projectSchema.services)) {
+            if (service.namespace === namespace) {
+                return serviceId;
+            }
+        }
+    }
+    return 'local';
+}
+function updateRefSyntax(projectSchema, $ref) {
+    const shapeName = $refToShapeName($ref);
+    const parts = shapeName.split('_');
+    const serviceId = parts.length === 1 ? 'local' : findServiceIdForNamespace(projectSchema, parts[0]);
+    return `${serviceId}:${parts[parts.length - 1]}`;
+}
+function migrateQueryToV3_10(projectSchema) {
+    return (query, queryName) => {
+        const { args, shape } = query;
+        if (typeof args === 'object' && ('oneOf' in args || 'allOf' in args || '$ref' in args || '@ref' in args)) {
+            // As of 11/15/2021 no production schemas contained queries with these args
+            throw new Error(`Query "${queryName}" contains an unsupported arg schema ${JSON.stringify(args)}. Please contact support`);
+        }
+        if (typeof shape === 'object') {
+            if (shape.items.$ref) {
+                return set('shape.items', { '@ref': updateRefSyntax(projectSchema, shape.items.$ref) }, query);
+            }
+            if (!shape.items['@ref']) {
+                // As of 11/15/2021 no production schemas contained queries with array return shapes that are not @refs
+                throw new Error(`Query "${queryName}" contains an unsupported shape schema ${JSON.stringify(shape)}. Please contact support`);
+            }
+        }
+        return query;
+    };
+}
+function migrateShapeToV3_10(shape) {
+    const { schema, ...rest } = shape;
+    // As of 11/15/2021 no production schemas contained shapes with array schemas
+    if ('type' in schema && schema.type === 'array') {
+        throw new Error(`Shape ${shape.name} uses an unsupported array schema. Please contact support`);
+    }
+    const newSchema = '$ref' in schema || '@ref' in schema ? { allOf: [schema] } : schema;
+    return {
+        ...rest,
+        schema: newSchema
+    };
+}
+const migrate = async (_, projectSchema) => {
+    const { queries, mutations, shapes, schemaVersion, ...rest } = projectSchema;
+    const migrate = migrateQueryToV3_10(projectSchema);
+    return {
+        ...rest,
+        queries: mapValues(queries, migrate),
+        mutations: mapValues(mutations, migrate),
+        shapes: mapValues(shapes, migrateShapeToV3_10),
+        schemaVersion: '3.10.0'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,85 @@
+import fromPairs from 'lodash/fromPairs.js';
+const migrate = async (context, projectSchema) => {
+    const { decryptFn, encryptFn } = context;
+    const migratedServices = [];
+    for (const [serviceKey, serviceConfig] of Object.entries(projectSchema.services ?? {})) {
+        const { authenticationType, authentication } = serviceConfig;
+        // Migrate authentication, ensuring now required properties
+        if (authentication && authenticationType !== 'unknown' && authenticationType !== 'none') {
+            const decrypted = decryptFn(authentication);
+            if (!decrypted) {
+                throw new Error(`Service "${serviceKey}" authentication could not be decrypted. Please contact support.`);
+            }
+            let migrated;
+            if (authenticationType === 'searchParams') {
+                migrated = {
+                    params: decrypted,
+                    type: authenticationType
+                };
+            }
+            if (authenticationType === 'basic') {
+                migrated = {
+                    username: '',
+                    password: '',
+                    ...decrypted,
+                    type: authenticationType
+                };
+            }
+            if (authenticationType === 'bearer') {
+                migrated = {
+                    token: '',
+                    ...decrypted,
+                    type: authenticationType
+                };
+            }
+            if (authenticationType === 'oauth2Bearer') {
+                migrated = {
+                    token: '',
+                    ...decrypted,
+                    type: authenticationType
+                };
+            }
+            if (authenticationType === 'oauth2') {
+                migrated = {
+                    grantType: 'clientCredentials',
+                    clientId: '',
+                    ...decrypted,
+                    type: authenticationType
+                };
+            }
+            if (authenticationType === 'aws') {
+                migrated = {
+                    awsAccessKeyId: '',
+                    awsSecretAccessKey: '',
+                    ...decrypted,
+                    type: authenticationType
+                };
+            }
+            if (authenticationType === 'custom') {
+                migrated = {
+                    ...decrypted,
+                    type: authenticationType
+                };
+            }
+            if (migrated) {
+                const migratedServiceConfig = {
+                    ...serviceConfig,
+                    authentication: encryptFn(migrated)
+                };
+                migratedServices.push([serviceKey, migratedServiceConfig]);
+            }
+            else {
+                migratedServices.push([serviceKey, serviceConfig]);
+            }
+        }
+        else {
+            migratedServices.push([serviceKey, serviceConfig]);
+        }
+    }
+    return {
+        ...projectSchema,
+        services: fromPairs(migratedServices),
+        schemaVersion: '3.11.0'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,87 @@
+import omit from 'lodash/omit.js';
+function hasWebhook(projectSchema, config) {
+    const queryName = config.queries?.single?.name;
+    if (!queryName) {
+        return false;
+    }
+    const resolver = projectSchema?.queries[queryName]?.resolver;
+    return resolver && 'service' in resolver && projectSchema?.services?.[resolver.service].provider === 'shopify';
+}
+const migrate = async (_, { indexedShapes: oldIndexedShapes, ...projectSchema }) => {
+    if (!oldIndexedShapes) {
+        return {
+            ...projectSchema,
+            schemaVersion: '3.12.3'
+        };
+    }
+    const indexedShapes = Object.fromEntries(Object.entries(oldIndexedShapes).map(([shapeName, config]) => {
+        const queries = {};
+        const triggers = [];
+        if (!config.queries) {
+            return [
+                shapeName,
+                {
+                    ...config,
+                    queries,
+                    triggers
+                }
+            ];
+        }
+        if (hasWebhook(projectSchema, config)) {
+            queries.get = config.queries.single;
+            triggers.push({
+                type: 'webhook',
+                query: 'get',
+                service: 'shopify',
+                events: ['products/create', 'products/update', 'products/delete']
+            });
+        }
+        const oldPagination = config.queries.all?.pagination;
+        const pagination = oldPagination === undefined
+            ? undefined
+            : oldPagination.type === 'cursor'
+                ? {
+                    ...oldPagination,
+                    itemsToIndexPath: oldPagination.itemsPath,
+                    pageSize: oldPagination.size,
+                    pageSizeArg: oldPagination.sizeArg
+                }
+                : oldPagination.type === 'offset'
+                    ? {
+                        ...oldPagination,
+                        itemsToIndexPath: oldPagination.itemsPath,
+                        itemTotalPath: oldPagination.totalPath,
+                        offsetArg: oldPagination.offsetParam
+                    }
+                    : {
+                        ...oldPagination,
+                        itemsToIndexPath: oldPagination.itemsPath,
+                        pageTotalPath: oldPagination.totalPagesPath
+                    };
+        queries.list = pagination
+            ? {
+                ...omit(config.queries.all, 'interval'),
+                pagination
+            }
+            : omit(config.queries.all, 'interval', 'pagination');
+        triggers.push({
+            type: 'schedule',
+            query: 'list',
+            interval: config.queries.all.interval ?? 60 * 24
+        });
+        return [
+            shapeName,
+            {
+                ...config,
+                queries,
+                triggers
+            }
+        ];
+    }));
+    return {
+        ...projectSchema,
+        schemaVersion: '3.12.3',
+        indexedShapes
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,17 @@
+import { visit } from '@takeshape/util';
+import get from 'lodash/get.js';
+const migrate = async (_, projectSchema) => {
+    visit(projectSchema, ['@relationship'], (relationship, path) => {
+        const parent = get(projectSchema, path.slice(0, -1));
+        parent['@backreference'] = { enabled: true };
+        if (relationship.relatedName) {
+            parent['@backreference'].name = relationship.relatedName;
+            relationship.relatedName = undefined;
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.13.0'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,22 @@
+import { visit } from '@takeshape/util';
+import get from 'lodash/get.js';
+import omit from 'lodash/omit.js';
+import set from 'lodash/set.js';
+const migrate = async (_, projectSchema) => {
+    visit(projectSchema, ['@user'], (_, path) => {
+        const parentPath = path.slice(0, -1);
+        const oldSchema = get(projectSchema, parentPath);
+        const newSchema = {
+            ...omit(oldSchema, ['@user', 'type']),
+            '@ref': 'local:TSUser',
+            '@input': { type: 'string' },
+            '@resolver': { name: 'takeshape:getUser', service: 'takeshape:local' }
+        };
+        set(projectSchema, parentPath, newSchema);
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.17.0'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,64 @@
+import { isDefined, visit } from '@takeshape/util';
+import get from 'lodash/get.js';
+import omit from 'lodash/omit.js';
+import set from 'lodash/set.js';
+const migrate = async (_, projectSchema) => {
+    visit(projectSchema, ['@relationship'], (relationship, path) => {
+        const propertyPath = path.slice(0, -1);
+        const originalPropertySchema = get(projectSchema, propertyPath);
+        const propertySchema = omit(originalPropertySchema, ['@relationship', 'type', '$ref']);
+        const shapeIdMap = new Map(Object.values(projectSchema.shapes).map((shape) => [shape.id, shape]));
+        const shapeIdsToShapeRefs = (shapeIds) => {
+            return shapeIds
+                .map((shapeId) => {
+                let shape;
+                if (shapeId === 'ASSET') {
+                    shape = { name: 'Asset' };
+                }
+                else {
+                    shape = shapeIdMap.get(shapeId);
+                }
+                if (!shape) {
+                    return;
+                }
+                return {
+                    '@ref': `local:${shape.name}`
+                };
+            })
+                .filter(isDefined);
+        };
+        const shapeRefs = shapeIdsToShapeRefs(relationship.shapeIds);
+        const shapeRefsSchema = shapeRefs.length === 1 ? shapeRefs[0] : { oneOf: shapeRefs };
+        if (relationship.type === 'multiple') {
+            propertySchema.type = 'array';
+            propertySchema.items = shapeRefsSchema;
+            propertySchema['@input'] = {
+                type: 'array',
+                items: {
+                    '@ref': 'local:TSRelationship'
+                }
+            };
+        }
+        else {
+            propertySchema.type = undefined;
+            Object.assign(propertySchema, shapeRefsSchema);
+            propertySchema['@input'] = {
+                '@ref': 'local:TSRelationship'
+            };
+        }
+        propertySchema['@args'] = 'TSRelationshipArgs';
+        propertySchema['@resolver'] = {
+            name: 'takeshape:getRelated',
+            service: 'takeshape:local',
+            options: {
+                nullable: true
+            }
+        };
+        set(projectSchema, propertyPath, propertySchema);
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.18.0'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,12 @@
+import pick from 'lodash/fp/pick.js';
+import mapValues from 'lodash/mapValues.js';
+const pruneQuery = pick(['args', 'resolver', 'shape', 'description']);
+const migrate = async (_, projectSchema) => {
+    return {
+        ...projectSchema,
+        queries: mapValues(projectSchema.queries, pruneQuery),
+        mutations: mapValues(projectSchema.mutations, pruneQuery),
+        schemaVersion: '3.18.1'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,19 @@
+import mapValues from 'lodash/mapValues.js';
+function updateGenericServices(projectSchema) {
+    if (projectSchema.services) {
+        return {
+            ...projectSchema,
+            services: mapValues(projectSchema.services, (serviceConfig) => 
+            // generic provider has been renamed to match service type
+            serviceConfig.provider === 'generic' ? { ...serviceConfig, provider: serviceConfig.serviceType } : serviceConfig)
+        };
+    }
+    return projectSchema;
+}
+const migrate = async (_, projectSchema) => {
+    return {
+        ...updateGenericServices(projectSchema),
+        schemaVersion: '3.18.2'
+    };
+};
+export default migrate;

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

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

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

@@ -0,0 +1,24 @@
+import mapValues from 'lodash/mapValues.js';
+function updateGenericServices(projectSchema) {
+    if (projectSchema.services) {
+        return {
+            ...projectSchema,
+            services: mapValues(projectSchema.services, (serviceConfig) => 
+            // generic provider has been renamed to match service type
+            serviceConfig.provider === 'shopify'
+                ? {
+                    ...serviceConfig,
+                    options: { ...serviceConfig.options, legacyApp: true }
+                }
+                : serviceConfig)
+        };
+    }
+    return projectSchema;
+}
+const migrate = async (_, projectSchema) => {
+    return {
+        ...updateGenericServices(projectSchema),
+        schemaVersion: '3.20.0'
+    };
+};
+export default migrate;

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

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