@takeshape/schema 11.40.0 → 11.41.0

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

@@ -0,0 +1,120 @@
+import migrateToV3_0_0 from "./to/v3.0.0.js";
+import migrateToV3_1_0 from "./to/v3.1.0.js";
+import migrateToV3_2_0 from "./to/v3.2.0.js";
+import migrateToV3_3_0 from "./to/v3.3.0.js";
+import migrateToV3_4_0 from "./to/v3.4.0.js";
+import migrateToV3_5_0 from "./to/v3.5.0.js";
+import migrateToV3_5_1 from "./to/v3.5.1.js";
+import migrateToV3_6_0 from "./to/v3.6.0.js";
+import migrateToV3_7_0 from "./to/v3.7.0.js";
+import migrateToV3_8_0 from "./to/v3.8.0.js";
+import migrateToV3_9_0 from "./to/v3.9.0.js";
+import migrateToV3_10_0 from "./to/v3.10.0.js";
+import migrateToV3_11_0 from "./to/v3.11.0.js";
+import migrateToV3_12_0 from "./to/v3.12.0.js";
+import migrateToV3_12_1 from "./to/v3.12.1.js";
+import migrateToV3_12_2 from "./to/v3.12.2.js";
+import migrateToV3_12_3 from "./to/v3.12.3.js";
+import migrateToV3_13_0 from "./to/v3.13.0.js";
+import migrateToV3_14_0 from "./to/v3.14.0.js";
+import migrateToV3_15_0 from "./to/v3.15.0.js";
+import migrateToV3_16_0 from "./to/v3.16.0.js";
+import migrateToV3_17_0 from "./to/v3.17.0.js";
+import migrateToV3_17_1 from "./to/v3.17.1.js";
+import migrateToV3_18_0 from "./to/v3.18.0.js";
+import migrateToV3_18_1 from "./to/v3.18.1.js";
+import migrateToV3_18_2 from "./to/v3.18.2.js";
+import migrateToV3_19_0 from "./to/v3.19.0.js";
+import migrateToV3_20_0 from "./to/v3.20.0.js";
+import migrateToV3_21_0 from "./to/v3.21.0.js";
+import migrateToV3_22_0 from "./to/v3.22.0.js";
+import migrateToV3_23_0 from "./to/v3.23.0.js";
+import migrateToV3_24_0 from "./to/v3.24.0.js";
+import migrateToV3_25_0 from "./to/v3.25.0.js";
+import migrateToV3_26_0 from "./to/v3.26.0.js";
+import migrateToV3_27_0 from "./to/v3.27.0.js";
+import migrateToV3_28_0 from "./to/v3.28.0.js";
+import migrateToV3_29_0 from "./to/v3.29.0.js";
+import migrateToV3_30_0 from "./to/v3.30.0.js";
+import migrateToV3_31_0 from "./to/v3.31.0.js";
+import migrateToV3_32_0 from "./to/v3.32.0.js";
+import migrateToV3_33_0 from "./to/v3.33.0.js";
+import migrateToV3_34_0 from "./to/v3.34.0.js";
+import migrateToV3_35_0 from "./to/v3.35.0.js";
+import migrateToV3_36_0 from "./to/v3.36.0.js";
+import migrateToV3_37_0 from "./to/v3.37.0.js";
+import migrateToV3_38_0 from "./to/v3.38.0.js";
+import migrateToV3_39_0 from "./to/v3.39.0.js";
+import migrateToV3_40_0 from "./to/v3.40.0.js";
+import migrateToV3_41_0 from "./to/v3.41.0.js";
+import migrateToV3_42_0 from "./to/v3.42.0.js";
+import migrateToV3_43_0 from "./to/v3.43.0.js";
+import migrateToV3_44_0 from "./to/v3.44.0.js";
+import migrateToV3_45_0 from "./to/v3.45.0.js";
+import migrateToV3_46_0 from "./to/v3.46.0.js";
+import migrateToV3_47_0 from "./to/v3.47.0.js";
+import migrateToV3_48_0 from "./to/v3.48.0.js";
+import migrateToV3_49_0 from "./to/v3.49.0.js";
+import migrateToV3_50_0 from "./to/v3.50.0.js";
+export const migrateTo = {
+    "v3.0.0": migrateToV3_0_0,
+    "v3.1.0": migrateToV3_1_0,
+    "v3.2.0": migrateToV3_2_0,
+    "v3.3.0": migrateToV3_3_0,
+    "v3.4.0": migrateToV3_4_0,
+    "v3.5.0": migrateToV3_5_0,
+    "v3.5.1": migrateToV3_5_1,
+    "v3.6.0": migrateToV3_6_0,
+    "v3.7.0": migrateToV3_7_0,
+    "v3.8.0": migrateToV3_8_0,
+    "v3.9.0": migrateToV3_9_0,
+    "v3.10.0": migrateToV3_10_0,
+    "v3.11.0": migrateToV3_11_0,
+    "v3.12.0": migrateToV3_12_0,
+    "v3.12.1": migrateToV3_12_1,
+    "v3.12.2": migrateToV3_12_2,
+    "v3.12.3": migrateToV3_12_3,
+    "v3.13.0": migrateToV3_13_0,
+    "v3.14.0": migrateToV3_14_0,
+    "v3.15.0": migrateToV3_15_0,
+    "v3.16.0": migrateToV3_16_0,
+    "v3.17.0": migrateToV3_17_0,
+    "v3.17.1": migrateToV3_17_1,
+    "v3.18.0": migrateToV3_18_0,
+    "v3.18.1": migrateToV3_18_1,
+    "v3.18.2": migrateToV3_18_2,
+    "v3.19.0": migrateToV3_19_0,
+    "v3.20.0": migrateToV3_20_0,
+    "v3.21.0": migrateToV3_21_0,
+    "v3.22.0": migrateToV3_22_0,
+    "v3.23.0": migrateToV3_23_0,
+    "v3.24.0": migrateToV3_24_0,
+    "v3.25.0": migrateToV3_25_0,
+    "v3.26.0": migrateToV3_26_0,
+    "v3.27.0": migrateToV3_27_0,
+    "v3.28.0": migrateToV3_28_0,
+    "v3.29.0": migrateToV3_29_0,
+    "v3.30.0": migrateToV3_30_0,
+    "v3.31.0": migrateToV3_31_0,
+    "v3.32.0": migrateToV3_32_0,
+    "v3.33.0": migrateToV3_33_0,
+    "v3.34.0": migrateToV3_34_0,
+    "v3.35.0": migrateToV3_35_0,
+    "v3.36.0": migrateToV3_36_0,
+    "v3.37.0": migrateToV3_37_0,
+    "v3.38.0": migrateToV3_38_0,
+    "v3.39.0": migrateToV3_39_0,
+    "v3.40.0": migrateToV3_40_0,
+    "v3.41.0": migrateToV3_41_0,
+    "v3.42.0": migrateToV3_42_0,
+    "v3.43.0": migrateToV3_43_0,
+    "v3.44.0": migrateToV3_44_0,
+    "v3.45.0": migrateToV3_45_0,
+    "v3.46.0": migrateToV3_46_0,
+    "v3.47.0": migrateToV3_47_0,
+    "v3.48.0": migrateToV3_48_0,
+    "v3.49.0": migrateToV3_49_0,
+    "v3.50.0": migrateToV3_50_0
+};
+export * from "./utils.js";
+export const listTypePrefix = "PaginatedList";

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

@@ -0,0 +1,200 @@
+import forEach from "lodash/forEach.js";
+import pick from "lodash/pick.js";
+import { pascalCase, deepClone } from "@takeshape/util";
+import { arraySchemaKeys, getShapeQueriesAndMutations, multipleRelationshipSchemaKeys, objectSchemaKeys, scalarSchemaKeys, schemaMetadataKeys } from "../../schema-util.js";
+import { formatDate } from "../utils.js";
+const annotationMap = {
+    l10n: "@l10n",
+    sensitive: "@sensitive",
+    syncLocaleStructure: "@syncLocaleStructure"
+};
+function isColor(schema) {
+    const { type, properties } = schema;
+    return Boolean(type === "object" && properties?.hsl && properties.hsv && properties.rgb && properties.hex);
+}
+function getModelType(contentType) {
+    if (contentType.single) {
+        return "single";
+    }
+    if (contentType.taxonomy) {
+        return "taxonomy";
+    }
+    return "multiple";
+}
+function getRelationshipSchema(relationship) {
+    const itemSchema = {
+        $ref: "#/shapes/TSRelationship/schema"
+    };
+    if (relationship.type === "multiple") {
+        return {
+            type: "array",
+            items: itemSchema,
+            "@relationship": relationship
+        };
+    }
+    return {
+        ...itemSchema,
+        "@relationship": relationship
+    };
+}
+// eslint-disable-next-line complexity
+function migrateToContentSchemaV3(params) {
+    const { schema, service, name, key, setSource, omitAllSources } = params;
+    const { type } = schema;
+    const mapping = !omitAllSources && key && setSource !== false && name !== key ? `${service}.${key}` : undefined;
+    forEach(schema, (value, key) => {
+        if (annotationMap[key]) {
+            const newAnnotation = annotationMap[key];
+            schema[newAnnotation] = value;
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete schema[key];
+        }
+    });
+    if (type === "string" || type === "boolean" || type === "number" || type === "integer") {
+        return { schema: { ...pick(schema, scalarSchemaKeys), "@mapping": mapping } };
+    }
+    const { relationship } = schema;
+    if (relationship) {
+        const { contentTypeIds, type: relationshipType, relatedName } = relationship;
+        return {
+            schema: {
+                ...pick(schema, relationshipType === "multiple" ? multipleRelationshipSchemaKeys : schemaMetadataKeys),
+                "@mapping": mapping,
+                ...getRelationshipSchema({
+                    shapeIds: contentTypeIds,
+                    type: relationshipType ?? "single", // Type is optional on assets
+                    relatedName
+                })
+            }
+        };
+    }
+    if (type === "object" && schema.draftjs) {
+        return { schema: { ...pick(schema, scalarSchemaKeys), "@mapping": mapping, "@tag": "draftjs" } };
+    }
+    if (isColor(schema)) {
+        return { schema: { ...pick(schema, scalarSchemaKeys), $ref: "#/shapes/TSColor/schema", "@mapping": mapping } };
+    }
+    if (type === "object" && schema.properties) {
+        const properties = {};
+        const shapes = {};
+        const shapeTitle = [params.shapeTitle, pascalCase(schema.title ?? params.name)].filter(Boolean).join(" ");
+        const shapeName = `${params.shapeName}${pascalCase(params.name)}`;
+        const contentSourceId = `takeshape:local:${shapeName}`;
+        forEach(schema.properties, (propSchema, name) => {
+            const { schema: migratedPropSchema, hoistedShapes } = migrateToContentSchemaV3({
+                ...params,
+                shapeName,
+                shapeTitle,
+                depth: params.depth + 1,
+                schema: propSchema,
+                parentSchema: schema,
+                service: contentSourceId,
+                key: propSchema.key ?? name,
+                name,
+                setSource: true
+            });
+            properties[name] = migratedPropSchema;
+            Object.assign(shapes, hoistedShapes);
+        });
+        if (params.depth > 0) {
+            const { title, description, ...rest } = schema;
+            return {
+                schema: {
+                    title,
+                    description,
+                    "@mapping": mapping,
+                    $ref: `#/shapes/${shapeName}/schema`
+                },
+                hoistedShapes: {
+                    ...shapes,
+                    [shapeName]: {
+                        id: name === key ? shapeName : key,
+                        name: shapeName,
+                        title: shapeTitle,
+                        schema: {
+                            ...pick(rest, objectSchemaKeys),
+                            type: "object",
+                            properties
+                        }
+                    }
+                }
+            };
+        }
+        return {
+            schema: {
+                ...pick(schema, objectSchemaKeys),
+                properties,
+                "@mapping": mapping
+            },
+            hoistedShapes: shapes
+        };
+    }
+    if (schema.type === "array" && schema.items) {
+        const { schema: itemSchema, hoistedShapes } = migrateToContentSchemaV3({
+            ...params,
+            schema: schema.items,
+            parentSchema: schema,
+            service: "parent",
+            setSource: false
+        });
+        return {
+            schema: {
+                ...pick(schema, arraySchemaKeys),
+                items: itemSchema,
+                "@mapping": mapping
+            },
+            hoistedShapes
+        };
+    }
+    throw new Error(`Unknown schema type "${type}"`);
+}
+function contentTypeToShape(contentType, contentTypeId) {
+    const title = contentType.title ?? contentType.name;
+    const name = pascalCase(contentType.name);
+    const contentSourceId = `takeshape:local:${name}`;
+    const { schema, hoistedShapes } = migrateToContentSchemaV3({
+        shapeName: name,
+        shapeTitle: title,
+        schema: contentType.schema,
+        service: contentSourceId,
+        name: "",
+        key: "",
+        depth: 0
+    });
+    return {
+        [name]: {
+            id: contentTypeId,
+            name,
+            title,
+            model: {
+                type: getModelType(contentType)
+            },
+            workflow: contentType.workflow,
+            schema: schema
+        },
+        ...hoistedShapes
+    };
+}
+const migrate = async (_, projectSchema) => {
+    const { contentTypes, created, updated, ...rest } = projectSchema;
+    const shapes = {};
+    const forms = {};
+    Object.keys(contentTypes).forEach(contentTypeId => {
+        const contentType = contentTypes[contentTypeId];
+        Object.assign(shapes, contentTypeToShape(contentType, contentTypeId));
+        forms[pascalCase(contentType.name)] = contentType.forms;
+    });
+    // Use deepClone to drop undefined values, this improves compatibility with validation and testing
+    // Schemas are typically saved in Dynamo or JSON files which also remove undefined values
+    // Dropping them here is done for consistency's sake
+    return deepClone({
+        ...rest,
+        ...getShapeQueriesAndMutations(Object.values(shapes)),
+        schemaVersion: "3",
+        created: formatDate(created),
+        updated: formatDate(updated),
+        shapes,
+        forms
+    });
+};
+export default migrate;

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

@@ -0,0 +1,192 @@
+import pReduce from "p-reduce";
+import isObject from "lodash/isObject.js";
+import isString from "lodash/isString.js";
+import isUndefined from "lodash/isUndefined.js";
+import { deepClone, pascalCase } from "@takeshape/util";
+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.
+ */
+// eslint-disable-next-line complexity
+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/esm/src/migration/to/v3.10.0.js

@@ -0,0 +1,67 @@
+import mapValues from 'lodash/mapValues.js';
+import set from 'lodash/fp/set.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/esm/src/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/esm/src/migration/to/v3.12.0.js

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

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

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