@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/domain/contentModel/validation/pluralApiName.js

@@ -0,0 +1,13 @@
+import error from "@webiny/error";
+const validatePluralApiName = (params)=>{
+    const { existingModel, model } = params;
+    if (existingModel.singularApiName === model.pluralApiName) throw new error(`Content model with singularApiName "${model.pluralApiName}" already exists.`, "MODEL_SINGULAR_API_NAME_EXISTS", {
+        input: model.pluralApiName
+    });
+    if (existingModel.pluralApiName === model.pluralApiName) throw new error(`Content model with pluralApiName "${model.pluralApiName}" already exists.`, "MODEL_PLURAL_API_NAME_EXISTS", {
+        input: model.pluralApiName
+    });
+};
+export { validatePluralApiName };
+
+//# sourceMappingURL=pluralApiName.js.map

package/domain/contentModel/validation/pluralApiName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/contentModel/validation/pluralApiName.js","sources":["../../../../src/domain/contentModel/validation/pluralApiName.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsModel } from \"~/types/index.js\";\n\ninterface Params {\n    existingModel: Pick<CmsModel, \"singularApiName\" | \"pluralApiName\">;\n    model: Pick<CmsModel, \"singularApiName\" | \"pluralApiName\">;\n}\n\nexport const validatePluralApiName = (params: Params): void => {\n    const { existingModel, model } = params;\n\n    if (existingModel.singularApiName === model.pluralApiName) {\n        throw new WebinyError(\n            `Content model with singularApiName \"${model.pluralApiName}\" already exists.`,\n            \"MODEL_SINGULAR_API_NAME_EXISTS\",\n            {\n                input: model.pluralApiName\n            }\n        );\n    } else if (existingModel.pluralApiName === model.pluralApiName) {\n        throw new WebinyError(\n            `Content model with pluralApiName \"${model.pluralApiName}\" already exists.`,\n            \"MODEL_PLURAL_API_NAME_EXISTS\",\n            {\n                input: model.pluralApiName\n            }\n        );\n    }\n};\n"],"names":["validatePluralApiName","params","existingModel","model","WebinyError"],"mappings":";AAQO,MAAMA,wBAAwB,CAACC;IAClC,MAAM,EAAEC,aAAa,EAAEC,KAAK,EAAE,GAAGF;IAEjC,IAAIC,cAAc,eAAe,KAAKC,MAAM,aAAa,EACrD,MAAM,IAAIC,MACN,CAAC,oCAAoC,EAAED,MAAM,aAAa,CAAC,iBAAiB,CAAC,EAC7E,kCACA;QACI,OAAOA,MAAM,aAAa;IAC9B;IAED,IAAID,cAAc,aAAa,KAAKC,MAAM,aAAa,EAC1D,MAAM,IAAIC,MACN,CAAC,kCAAkC,EAAED,MAAM,aAAa,CAAC,iBAAiB,CAAC,EAC3E,gCACA;QACI,OAAOA,MAAM,aAAa;IAC9B;AAGZ"}

package/domain/contentModel/validation/singularApiName.d.ts

@@ -0,0 +1,7 @@
+import type { CmsModel } from "../../../types/index.js";
+interface Params {
+    existingModel: Pick<CmsModel, "singularApiName" | "pluralApiName">;
+    model: Pick<CmsModel, "singularApiName" | "pluralApiName">;
+}
+export declare const validateSingularApiName: (params: Params) => void;
+export {};

package/domain/contentModel/validation/singularApiName.js

@@ -0,0 +1,13 @@
+import error from "@webiny/error";
+const validateSingularApiName = (params)=>{
+    const { existingModel, model } = params;
+    if (existingModel.singularApiName === model.singularApiName) throw new error(`Content model with singularApiName "${model.singularApiName}" already exists.`, "MODEL_SINGULAR_API_NAME_EXISTS", {
+        input: model.singularApiName
+    });
+    if (existingModel.pluralApiName === model.singularApiName) throw new error(`Content model with pluralApiName "${model.singularApiName}" already exists.`, "MODEL_PLURAL_API_NAME_EXISTS", {
+        input: model.singularApiName
+    });
+};
+export { validateSingularApiName };
+
+//# sourceMappingURL=singularApiName.js.map

package/domain/contentModel/validation/singularApiName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/contentModel/validation/singularApiName.js","sources":["../../../../src/domain/contentModel/validation/singularApiName.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsModel } from \"~/types/index.js\";\n\ninterface Params {\n    existingModel: Pick<CmsModel, \"singularApiName\" | \"pluralApiName\">;\n    model: Pick<CmsModel, \"singularApiName\" | \"pluralApiName\">;\n}\n\nexport const validateSingularApiName = (params: Params): void => {\n    const { existingModel, model } = params;\n\n    if (existingModel.singularApiName === model.singularApiName) {\n        throw new WebinyError(\n            `Content model with singularApiName \"${model.singularApiName}\" already exists.`,\n            \"MODEL_SINGULAR_API_NAME_EXISTS\",\n            {\n                input: model.singularApiName\n            }\n        );\n    } else if (existingModel.pluralApiName === model.singularApiName) {\n        throw new WebinyError(\n            `Content model with pluralApiName \"${model.singularApiName}\" already exists.`,\n            \"MODEL_PLURAL_API_NAME_EXISTS\",\n            {\n                input: model.singularApiName\n            }\n        );\n    }\n};\n"],"names":["validateSingularApiName","params","existingModel","model","WebinyError"],"mappings":";AAQO,MAAMA,0BAA0B,CAACC;IACpC,MAAM,EAAEC,aAAa,EAAEC,KAAK,EAAE,GAAGF;IAEjC,IAAIC,cAAc,eAAe,KAAKC,MAAM,eAAe,EACvD,MAAM,IAAIC,MACN,CAAC,oCAAoC,EAAED,MAAM,eAAe,CAAC,iBAAiB,CAAC,EAC/E,kCACA;QACI,OAAOA,MAAM,eAAe;IAChC;IAED,IAAID,cAAc,aAAa,KAAKC,MAAM,eAAe,EAC5D,MAAM,IAAIC,MACN,CAAC,kCAAkC,EAAED,MAAM,eAAe,CAAC,iBAAiB,CAAC,EAC7E,gCACA;QACI,OAAOA,MAAM,eAAe;IAChC;AAGZ"}

package/domain/contentModelGroup/errors.d.ts

@@ -0,0 +1,38 @@
+import { BaseError } from "@webiny/feature/api";
+import type { OutputErrors } from "@webiny/utils/createZodError.js";
+export declare class GroupNotFoundError extends BaseError {
+    readonly code: "Cms/ModelGroup/NotFound";
+    constructor(groupId: string);
+}
+export declare class GroupSlugTakenError extends BaseError {
+    readonly code: "Cms/ModelGroup/SlugTaken";
+    constructor(slug: string);
+}
+export declare class GroupPersistenceError extends BaseError {
+    readonly code: "Cms/ModelGroup/PersistenceError";
+    constructor(error: Error);
+}
+interface ValidationParams {
+    invalidFields: OutputErrors;
+}
+export declare class GroupValidationError extends BaseError<ValidationParams> {
+    readonly code: "Cms/ModelGroup/ValidationFailed";
+    constructor(message: string, invalidFields: OutputErrors);
+}
+export declare class GroupCannotUpdateCodeDefinedError extends BaseError {
+    readonly code: "Cms/ModelGroup/CannotUpdateCodeGroup";
+    constructor(groupId: string);
+}
+export declare class GroupCannotDeleteCodeDefinedError extends BaseError {
+    readonly code: "Cms/ModelGroup/CannotDeleteCodeGroup";
+    constructor(groupId: string);
+}
+export declare class GroupHasModelsError extends BaseError {
+    readonly code: "Cms/ModelGroup/HasModels";
+    constructor();
+}
+export declare class GroupNotAuthorizedError extends BaseError {
+    readonly code: "Cms/ModelGroup/NotAuthorized";
+    constructor(message?: string);
+}
+export {};

package/domain/contentModelGroup/errors.js

@@ -0,0 +1,63 @@
+import { BaseError } from "@webiny/feature/api";
+class GroupNotFoundError extends BaseError {
+    constructor(groupId){
+        super({
+            message: `Group "${groupId}" was not found!`
+        }), this.code = "Cms/ModelGroup/NotFound";
+    }
+}
+class GroupSlugTakenError extends BaseError {
+    constructor(slug){
+        super({
+            message: `Group with the slug "${slug}" already exists.`
+        }), this.code = "Cms/ModelGroup/SlugTaken";
+    }
+}
+class GroupPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message
+        }), this.code = "Cms/ModelGroup/PersistenceError";
+    }
+}
+class GroupValidationError extends BaseError {
+    constructor(message, invalidFields){
+        super({
+            message,
+            data: {
+                invalidFields
+            }
+        }), this.code = "Cms/ModelGroup/ValidationFailed";
+    }
+}
+class GroupCannotUpdateCodeDefinedError extends BaseError {
+    constructor(groupId){
+        super({
+            message: `Cannot update code-defined group "${groupId}"`
+        }), this.code = "Cms/ModelGroup/CannotUpdateCodeGroup";
+    }
+}
+class GroupCannotDeleteCodeDefinedError extends BaseError {
+    constructor(groupId){
+        super({
+            message: `Cannot delete code-defined group "${groupId}"`
+        }), this.code = "Cms/ModelGroup/CannotDeleteCodeGroup";
+    }
+}
+class GroupHasModelsError extends BaseError {
+    constructor(){
+        super({
+            message: "Cannot delete this group because there are models that belong to it."
+        }), this.code = "Cms/ModelGroup/HasModels";
+    }
+}
+class GroupNotAuthorizedError extends BaseError {
+    constructor(message){
+        super({
+            message: message || "Not allowed to access content model groups."
+        }), this.code = "Cms/ModelGroup/NotAuthorized";
+    }
+}
+export { GroupCannotDeleteCodeDefinedError, GroupCannotUpdateCodeDefinedError, GroupHasModelsError, GroupNotAuthorizedError, GroupNotFoundError, GroupPersistenceError, GroupSlugTakenError, GroupValidationError };
+
+//# sourceMappingURL=errors.js.map

package/domain/contentModelGroup/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/contentModelGroup/errors.js","sources":["../../../src/domain/contentModelGroup/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\nimport type { OutputErrors } from \"@webiny/utils/createZodError.js\";\n\nexport class GroupNotFoundError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/NotFound\" as const;\n\n    constructor(groupId: string) {\n        super({\n            message: `Group \"${groupId}\" was not found!`\n        });\n    }\n}\n\nexport class GroupSlugTakenError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/SlugTaken\" as const;\n\n    constructor(slug: string) {\n        super({\n            message: `Group with the slug \"${slug}\" already exists.`\n        });\n    }\n}\n\nexport class GroupPersistenceError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: error.message\n        });\n    }\n}\n\ninterface ValidationParams {\n    invalidFields: OutputErrors;\n}\n\nexport class GroupValidationError extends BaseError<ValidationParams> {\n    override readonly code = \"Cms/ModelGroup/ValidationFailed\" as const;\n\n    constructor(message: string, invalidFields: OutputErrors) {\n        super({ message, data: { invalidFields } });\n    }\n}\n\nexport class GroupCannotUpdateCodeDefinedError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/CannotUpdateCodeGroup\" as const;\n\n    constructor(groupId: string) {\n        super({\n            message: `Cannot update code-defined group \"${groupId}\"`\n        });\n    }\n}\n\nexport class GroupCannotDeleteCodeDefinedError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/CannotDeleteCodeGroup\" as const;\n\n    constructor(groupId: string) {\n        super({\n            message: `Cannot delete code-defined group \"${groupId}\"`\n        });\n    }\n}\n\nexport class GroupHasModelsError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/HasModels\" as const;\n\n    constructor() {\n        super({\n            message: `Cannot delete this group because there are models that belong to it.`\n        });\n    }\n}\n\nexport class GroupNotAuthorizedError extends BaseError {\n    override readonly code = \"Cms/ModelGroup/NotAuthorized\" as const;\n\n    constructor(message?: string) {\n        super({\n            message: message || \"Not allowed to access content model groups.\"\n        });\n    }\n}\n"],"names":["GroupNotFoundError","BaseError","groupId","GroupSlugTakenError","slug","GroupPersistenceError","error","GroupValidationError","message","invalidFields","GroupCannotUpdateCodeDefinedError","GroupCannotDeleteCodeDefinedError","GroupHasModelsError","GroupNotAuthorizedError"],"mappings":";AAGO,MAAMA,2BAA2BC;IAGpC,YAAYC,OAAe,CAAE;QACzB,KAAK,CAAC;YACF,SAAS,CAAC,OAAO,EAAEA,QAAQ,gBAAgB,CAAC;QAChD,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMC,4BAA4BF;IAGrC,YAAYG,IAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAAS,CAAC,qBAAqB,EAAEA,KAAK,iBAAiB,CAAC;QAC5D,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMC,8BAA8BJ;IAGvC,YAAYK,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAASA,MAAM,OAAO;QAC1B,SALc,IAAI,GAAG;IAMzB;AACJ;AAMO,MAAMC,6BAA6BN;IAGtC,YAAYO,OAAe,EAAEC,aAA2B,CAAE;QACtD,KAAK,CAAC;YAAED;YAAS,MAAM;gBAAEC;YAAc;QAAE,SAH3B,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,0CAA0CT;IAGnD,YAAYC,OAAe,CAAE;QACzB,KAAK,CAAC;YACF,SAAS,CAAC,kCAAkC,EAAEA,QAAQ,CAAC,CAAC;QAC5D,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMS,0CAA0CV;IAGnD,YAAYC,OAAe,CAAE;QACzB,KAAK,CAAC;YACF,SAAS,CAAC,kCAAkC,EAAEA,QAAQ,CAAC,CAAC;QAC5D,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMU,4BAA4BX;IAGrC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMY,gCAAgCZ;IAGzC,YAAYO,OAAgB,CAAE;QAC1B,KAAK,CAAC;YACF,SAASA,WAAW;QACxB,SALc,IAAI,GAAG;IAMzB;AACJ"}

package/domain/contentModelGroup/validation.d.ts

@@ -0,0 +1,41 @@
+import zod from "zod";
+export declare const createGroupCreateValidation: () => zod.ZodObject<{
+    id: zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodString>>>;
+    name: zod.ZodString;
+    slug: zod.ZodPipe<zod.ZodOptional<zod.ZodString>, zod.ZodTransform<string, string | undefined>>;
+    description: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodString>>>, zod.ZodTransform<string, string | null | undefined>>;
+    icon: zod.ZodPipe<zod.ZodDefault<zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodObject<{
+        type: zod.ZodString;
+        name: zod.ZodString;
+        value: zod.ZodOptional<zod.ZodString>;
+    }, zod.core.$loose>>>>>, zod.ZodTransform<{
+        [x: string]: unknown;
+        type: string;
+        name: string;
+        value?: string | undefined;
+    } | null, {
+        [x: string]: unknown;
+        type: string;
+        name: string;
+        value?: string | undefined;
+    } | null>>;
+}, zod.core.$strip>;
+export declare const createGroupUpdateValidation: () => zod.ZodObject<{
+    name: zod.ZodOptional<zod.ZodString>;
+    description: zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodString>>>;
+    icon: zod.ZodOptional<zod.ZodPipe<zod.ZodDefault<zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodObject<{
+        type: zod.ZodString;
+        name: zod.ZodString;
+        value: zod.ZodOptional<zod.ZodString>;
+    }, zod.core.$loose>>>>>, zod.ZodTransform<{
+        [x: string]: unknown;
+        type: string;
+        name: string;
+        value?: string | undefined;
+    } | null, {
+        [x: string]: unknown;
+        type: string;
+        name: string;
+        value?: string | undefined;
+    } | null>>>;
+}, zod.core.$strip>;

package/domain/contentModelGroup/validation.js

@@ -0,0 +1,31 @@
+import zod from "zod";
+import { toSlug } from "../../utils/toSlug.js";
+const str = zod.string().trim();
+const validation_name = str.max(100);
+const description = str.max(255).optional().nullish();
+const icon = zod.looseObject({
+    type: zod.string(),
+    name: zod.string(),
+    value: zod.string().optional()
+}).optional().nullish().default(null).transform((value)=>{
+    if ("string" == typeof value) return {
+        type: "icon",
+        name: value
+    };
+    return value;
+});
+const createGroupCreateValidation = ()=>zod.object({
+        id: str.optional().nullish(),
+        name: validation_name.min(1),
+        slug: str.max(100).optional().transform((value)=>value ? toSlug(value) : ""),
+        description: description.transform((value)=>value || ""),
+        icon: icon
+    });
+const createGroupUpdateValidation = ()=>zod.object({
+        name: validation_name.optional(),
+        description: description,
+        icon: icon.optional()
+    });
+export { createGroupCreateValidation, createGroupUpdateValidation };
+
+//# sourceMappingURL=validation.js.map

package/domain/contentModelGroup/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/contentModelGroup/validation.js","sources":["../../../src/domain/contentModelGroup/validation.ts"],"sourcesContent":["import zod from \"zod\";\nimport { toSlug } from \"~/utils/toSlug.js\";\n\nconst str = zod.string().trim();\n\nconst name = str.max(100);\nconst description = str.max(255).optional().nullish();\nconst icon = zod\n    .looseObject({\n        type: zod.string(),\n        name: zod.string(),\n        value: zod.string().optional()\n    })\n    .optional()\n    .nullish()\n    .default(null)\n    .transform(value => {\n        if (typeof value === \"string\") {\n            return {\n                type: \"icon\",\n                name: value\n            };\n        }\n        return value;\n    });\nexport const createGroupCreateValidation = () => {\n    return zod.object({\n        id: str.optional().nullish(),\n        name: name.min(1),\n        slug: str\n            .max(100)\n            .optional()\n            .transform(value => {\n                return value ? toSlug(value) : \"\";\n            }),\n        description: description.transform(value => {\n            return value || \"\";\n        }),\n        icon\n    });\n};\n\nexport const createGroupUpdateValidation = () => {\n    return zod.object({\n        name: name.optional(),\n        description,\n        icon: icon.optional()\n    });\n};\n"],"names":["str","zod","name","description","icon","value","createGroupCreateValidation","toSlug","createGroupUpdateValidation"],"mappings":";;AAGA,MAAMA,MAAMC,IAAI,MAAM,GAAG,IAAI;AAE7B,MAAMC,kBAAOF,IAAI,GAAG,CAAC;AACrB,MAAMG,cAAcH,IAAI,GAAG,CAAC,KAAK,QAAQ,GAAG,OAAO;AACnD,MAAMI,OAAOH,IAAAA,WACG,CAAC;IACT,MAAMA,IAAI,MAAM;IAChB,MAAMA,IAAI,MAAM;IAChB,OAAOA,IAAI,MAAM,GAAG,QAAQ;AAChC,GACC,QAAQ,GACR,OAAO,GACP,OAAO,CAAC,MACR,SAAS,CAACI,CAAAA;IACP,IAAI,AAAiB,YAAjB,OAAOA,OACP,OAAO;QACH,MAAM;QACN,MAAMA;IACV;IAEJ,OAAOA;AACX;AACG,MAAMC,8BAA8B,IAChCL,IAAI,MAAM,CAAC;QACd,IAAID,IAAI,QAAQ,GAAG,OAAO;QAC1B,MAAME,gBAAK,GAAG,CAAC;QACf,MAAMF,IACD,GAAG,CAAC,KACJ,QAAQ,GACR,SAAS,CAACK,CAAAA,QACAA,QAAQE,OAAOF,SAAS;QAEvC,aAAaF,YAAY,SAAS,CAACE,CAAAA,QACxBA,SAAS;QAEpBD,MAAAA;IACJ;AAGG,MAAMI,8BAA8B,IAChCP,IAAI,MAAM,CAAC;QACd,MAAMC,gBAAK,QAAQ;QACnBC,aAAAA;QACA,MAAMC,KAAK,QAAQ;IACvB"}

package/export/crud/exporting.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessCmsExportStructure } from "../../export/types.js";
+import type { CmsContext } from "../../types/index.js";
+export declare const createExportStructureContext: (context: CmsContext) => HeadlessCmsExportStructure;

package/export/crud/exporting.js

@@ -0,0 +1,22 @@
+import { sanitizeGroup, sanitizeModel } from "./sanitize.js";
+const createExportStructureContext = (context)=>async (params)=>{
+        const { models: modelIdList } = params;
+        const groups = (await context.cms.listGroups()).map(sanitizeGroup);
+        const models = (await context.cms.listModels()).filter((model)=>{
+            if (model.isPrivate) return false;
+            if (!model.fields?.length) return false;
+            if (!modelIdList?.length) return true;
+            return modelIdList.includes(model.modelId);
+        }).map((model)=>{
+            const group = groups.find((group)=>group.slug === model.group);
+            if (!group) return null;
+            return sanitizeModel(group, model);
+        }).filter((model)=>!!model);
+        return {
+            groups: groups.filter((group)=>models.some((model)=>model.group === group.slug)),
+            models
+        };
+    };
+export { createExportStructureContext };
+
+//# sourceMappingURL=exporting.js.map

package/export/crud/exporting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export/crud/exporting.js","sources":["../../../src/export/crud/exporting.ts"],"sourcesContent":["import type { HeadlessCmsExportStructure, SanitizedCmsModel } from \"~/export/types.js\";\nimport type { CmsContext } from \"~/types/index.js\";\nimport { sanitizeGroup, sanitizeModel } from \"./sanitize.js\";\n\nexport const createExportStructureContext = (context: CmsContext): HeadlessCmsExportStructure => {\n    return async params => {\n        const { models: modelIdList } = params;\n        const groups = (await context.cms.listGroups()).map(sanitizeGroup);\n        /**\n         * We need all the models which:\n         * * are accessible by current user\n         * * are not private\n         * * are included (if targets are provided)\n         * * are part of one of the groups we already fetched\n         */\n        const models = (await context.cms.listModels())\n            .filter(model => {\n                if (model.isPrivate) {\n                    return false;\n                } else if (!model.fields?.length) {\n                    return false;\n                } else if (!modelIdList?.length) {\n                    return true;\n                }\n                return modelIdList.includes(model.modelId);\n            })\n            .map(model => {\n                const group = groups.find(group => group.slug === model.group);\n                if (!group) {\n                    return null;\n                }\n                return sanitizeModel(group, model);\n            })\n            .filter((model): model is SanitizedCmsModel => {\n                return !!model;\n            });\n\n        return {\n            groups: groups.filter(group => {\n                return models.some(model => model.group === group.slug);\n            }),\n            models\n        };\n    };\n};\n"],"names":["createExportStructureContext","context","params","modelIdList","groups","sanitizeGroup","models","model","group","sanitizeModel"],"mappings":";AAIO,MAAMA,+BAA+B,CAACC,UAClC,OAAMC;QACT,MAAM,EAAE,QAAQC,WAAW,EAAE,GAAGD;QAChC,MAAME,SAAU,OAAMH,QAAQ,GAAG,CAAC,UAAU,EAAC,EAAG,GAAG,CAACI;QAQpD,MAAMC,SAAU,OAAML,QAAQ,GAAG,CAAC,UAAU,EAAC,EACxC,MAAM,CAACM,CAAAA;YACJ,IAAIA,MAAM,SAAS,EACf,OAAO;YACJ,IAAI,CAACA,MAAM,MAAM,EAAE,QACtB,OAAO;YACJ,IAAI,CAACJ,aAAa,QACrB,OAAO;YAEX,OAAOA,YAAY,QAAQ,CAACI,MAAM,OAAO;QAC7C,GACC,GAAG,CAACA,CAAAA;YACD,MAAMC,QAAQJ,OAAO,IAAI,CAACI,CAAAA,QAASA,MAAM,IAAI,KAAKD,MAAM,KAAK;YAC7D,IAAI,CAACC,OACD,OAAO;YAEX,OAAOC,cAAcD,OAAOD;QAChC,GACC,MAAM,CAAC,CAACA,QACE,CAAC,CAACA;QAGjB,OAAO;YACH,QAAQH,OAAO,MAAM,CAACI,CAAAA,QACXF,OAAO,IAAI,CAACC,CAAAA,QAASA,MAAM,KAAK,KAAKC,MAAM,IAAI;YAE1DF;QACJ;IACJ"}

package/export/crud/importing.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessCmsImport } from "../../export/types.js";
+import type { CmsContext } from "../../types/index.js";
+export declare const createImportCrud: (context: CmsContext) => HeadlessCmsImport;

package/export/crud/importing.js

@@ -0,0 +1,52 @@
+import _webiny_error from "@webiny/error";
+import { importData } from "./imports/importData.js";
+import { validateInput } from "./imports/validateInput.js";
+const fetchGroupsAndModels = async (context)=>await context.security.withoutAuthorization(async ()=>({
+            groups: await context.cms.listGroups(),
+            models: await context.cms.listModels()
+        }));
+const createImportCrud = (context)=>({
+        validate: async (params)=>{
+            const { data } = params;
+            const { groups, models } = await fetchGroupsAndModels(context);
+            const validated = await validateInput({
+                groups,
+                models,
+                data
+            });
+            if (validated.error) return {
+                groups: validated.groups,
+                models: validated.models,
+                message: validated.error
+            };
+            return {
+                groups: validated.groups,
+                models: validated.models,
+                message: "Validation done."
+            };
+        },
+        structure: async (params)=>{
+            const { data } = params;
+            const { groups, models } = await fetchGroupsAndModels(context);
+            const validated = await validateInput({
+                groups,
+                models,
+                data
+            });
+            if (validated.error) throw new _webiny_error(validated.error, "VALIDATION_ERROR");
+            const imported = await importData({
+                context,
+                groups: validated.groups,
+                models: validated.models
+            });
+            const modelError = imported.models.find((model)=>!!model.error);
+            const error = imported.error || modelError;
+            return {
+                ...imported,
+                message: error ? null : "Import done."
+            };
+        }
+    });
+export { createImportCrud };
+
+//# sourceMappingURL=importing.js.map

package/export/crud/importing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export/crud/importing.js","sources":["../../../src/export/crud/importing.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type {\n    HeadlessCmsImport,\n    ValidCmsGroupResult,\n    ValidCmsModelResult\n} from \"~/export/types.js\";\nimport type { CmsContext } from \"~/types/index.js\";\nimport { importData } from \"./imports/importData.js\";\nimport { validateInput } from \"./imports/validateInput.js\";\n\nconst fetchGroupsAndModels = async (context: CmsContext) => {\n    return await context.security.withoutAuthorization(async () => {\n        return {\n            groups: await context.cms.listGroups(),\n            models: await context.cms.listModels()\n        };\n    });\n};\n\nexport const createImportCrud = (context: CmsContext): HeadlessCmsImport => {\n    return {\n        validate: async params => {\n            const { data } = params;\n\n            const { groups, models } = await fetchGroupsAndModels(context);\n\n            const validated = await validateInput({\n                groups,\n                models,\n                data\n            });\n            if (validated.error) {\n                return {\n                    groups: validated.groups,\n                    models: validated.models,\n                    message: validated.error\n                };\n            }\n\n            return {\n                groups: validated.groups,\n                models: validated.models,\n                message: \"Validation done.\"\n            };\n        },\n        structure: async params => {\n            const { data } = params;\n\n            const { groups, models } = await fetchGroupsAndModels(context);\n\n            const validated = await validateInput({\n                groups,\n                models,\n                data\n            });\n            if (validated.error) {\n                throw new WebinyError(validated.error, \"VALIDATION_ERROR\");\n            }\n\n            const imported = await importData({\n                context,\n                groups: validated.groups as ValidCmsGroupResult[],\n                models: validated.models as ValidCmsModelResult[]\n            });\n\n            const modelError = imported.models.find(model => !!model.error);\n            const error = imported.error || modelError;\n\n            return {\n                ...imported,\n                message: error ? null : \"Import done.\"\n            };\n        }\n    };\n};\n"],"names":["fetchGroupsAndModels","context","createImportCrud","params","data","groups","models","validated","validateInput","WebinyError","imported","importData","modelError","model","error"],"mappings":";;;AAUA,MAAMA,uBAAuB,OAAOC,UACzB,MAAMA,QAAQ,QAAQ,CAAC,oBAAoB,CAAC,UACxC;YACH,QAAQ,MAAMA,QAAQ,GAAG,CAAC,UAAU;YACpC,QAAQ,MAAMA,QAAQ,GAAG,CAAC,UAAU;QACxC;AAID,MAAMC,mBAAmB,CAACD,UACtB;QACH,UAAU,OAAME;YACZ,MAAM,EAAEC,IAAI,EAAE,GAAGD;YAEjB,MAAM,EAAEE,MAAM,EAAEC,MAAM,EAAE,GAAG,MAAMN,qBAAqBC;YAEtD,MAAMM,YAAY,MAAMC,cAAc;gBAClCH;gBACAC;gBACAF;YACJ;YACA,IAAIG,UAAU,KAAK,EACf,OAAO;gBACH,QAAQA,UAAU,MAAM;gBACxB,QAAQA,UAAU,MAAM;gBACxB,SAASA,UAAU,KAAK;YAC5B;YAGJ,OAAO;gBACH,QAAQA,UAAU,MAAM;gBACxB,QAAQA,UAAU,MAAM;gBACxB,SAAS;YACb;QACJ;QACA,WAAW,OAAMJ;YACb,MAAM,EAAEC,IAAI,EAAE,GAAGD;YAEjB,MAAM,EAAEE,MAAM,EAAEC,MAAM,EAAE,GAAG,MAAMN,qBAAqBC;YAEtD,MAAMM,YAAY,MAAMC,cAAc;gBAClCH;gBACAC;gBACAF;YACJ;YACA,IAAIG,UAAU,KAAK,EACf,MAAM,IAAIE,cAAYF,UAAU,KAAK,EAAE;YAG3C,MAAMG,WAAW,MAAMC,WAAW;gBAC9BV;gBACA,QAAQM,UAAU,MAAM;gBACxB,QAAQA,UAAU,MAAM;YAC5B;YAEA,MAAMK,aAAaF,SAAS,MAAM,CAAC,IAAI,CAACG,CAAAA,QAAS,CAAC,CAACA,MAAM,KAAK;YAC9D,MAAMC,QAAQJ,SAAS,KAAK,IAAIE;YAEhC,OAAO;gBACH,GAAGF,QAAQ;gBACX,SAASI,QAAQ,OAAO;YAC5B;QACJ;IACJ"}

package/export/crud/imports/importData.d.ts

@@ -0,0 +1,14 @@
+import type { CmsGroupImportResult, CmsModelImportResult, ValidCmsGroupResult, ValidCmsModelResult } from "../../../export/types.js";
+import type { CmsContext } from "../../../types/index.js";
+interface Params {
+    context: CmsContext;
+    groups: ValidCmsGroupResult[];
+    models: ValidCmsModelResult[];
+}
+interface Response {
+    groups: CmsGroupImportResult[];
+    models: CmsModelImportResult[];
+    error?: string;
+}
+export declare const importData: (params: Params) => Promise<Response>;
+export {};

package/export/crud/imports/importData.js

@@ -0,0 +1,34 @@
+import { importGroups } from "./importGroups.js";
+import { importModels } from "./importModels.js";
+const getGroup = (params)=>{
+    const { validated, imported, target } = params;
+    const group = imported.find((group)=>group.group.id === target);
+    if (group) return group.group.id;
+    const validatedGroup = validated.find((group)=>group.group.id === target || group.target === target);
+    return validatedGroup?.target || validatedGroup?.group.id;
+};
+const importData = async (params)=>{
+    const { context } = params;
+    const groups = await importGroups(params);
+    const models = await importModels({
+        context,
+        models: params.models.map((model)=>{
+            const group = getGroup({
+                validated: params.groups,
+                imported: groups,
+                target: model.model.group
+            });
+            return {
+                ...model,
+                group: group || model.model.group
+            };
+        })
+    });
+    return {
+        groups,
+        models
+    };
+};
+export { importData };
+
+//# sourceMappingURL=importData.js.map

package/export/crud/imports/importData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export/crud/imports/importData.js","sources":["../../../../src/export/crud/imports/importData.ts"],"sourcesContent":["import type {\n    CmsGroupImportResult,\n    CmsModelImportResult,\n    ValidCmsGroupResult,\n    ValidCmsModelResult\n} from \"~/export/types.js\";\nimport type { CmsContext } from \"~/types/index.js\";\nimport { importGroups } from \"./importGroups.js\";\nimport { importModels } from \"./importModels.js\";\n\ninterface Params {\n    context: CmsContext;\n    groups: ValidCmsGroupResult[];\n    models: ValidCmsModelResult[];\n}\n\ninterface Response {\n    groups: CmsGroupImportResult[];\n    models: CmsModelImportResult[];\n    error?: string;\n}\n\ninterface GetGroupParams {\n    validated: ValidCmsGroupResult[];\n    imported: CmsGroupImportResult[];\n    target: string;\n}\n\nconst getGroup = (params: GetGroupParams) => {\n    const { validated, imported, target } = params;\n    const group = imported.find(group => {\n        return group.group.id === target;\n    });\n    if (group) {\n        return group.group.id;\n    }\n    const validatedGroup = validated.find(group => {\n        return group.group.id === target || group.target === target;\n    });\n    return validatedGroup?.target || validatedGroup?.group.id;\n};\n\nexport const importData = async (params: Params): Promise<Response> => {\n    const { context } = params;\n\n    const groups = await importGroups(params);\n\n    const models = await importModels({\n        context,\n        models: params.models.map(model => {\n            const group = getGroup({\n                validated: params.groups,\n                imported: groups,\n                target: model.model.group\n            });\n            return {\n                ...model,\n                group: group || model.model.group\n            };\n        })\n    });\n\n    return {\n        groups,\n        models\n    };\n};\n"],"names":["getGroup","params","validated","imported","target","group","validatedGroup","importData","context","groups","importGroups","models","importModels","model"],"mappings":";;AA4BA,MAAMA,WAAW,CAACC;IACd,MAAM,EAAEC,SAAS,EAAEC,QAAQ,EAAEC,MAAM,EAAE,GAAGH;IACxC,MAAMI,QAAQF,SAAS,IAAI,CAACE,CAAAA,QACjBA,MAAM,KAAK,CAAC,EAAE,KAAKD;IAE9B,IAAIC,OACA,OAAOA,MAAM,KAAK,CAAC,EAAE;IAEzB,MAAMC,iBAAiBJ,UAAU,IAAI,CAACG,CAAAA,QAC3BA,MAAM,KAAK,CAAC,EAAE,KAAKD,UAAUC,MAAM,MAAM,KAAKD;IAEzD,OAAOE,gBAAgB,UAAUA,gBAAgB,MAAM;AAC3D;AAEO,MAAMC,aAAa,OAAON;IAC7B,MAAM,EAAEO,OAAO,EAAE,GAAGP;IAEpB,MAAMQ,SAAS,MAAMC,aAAaT;IAElC,MAAMU,SAAS,MAAMC,aAAa;QAC9BJ;QACA,QAAQP,OAAO,MAAM,CAAC,GAAG,CAACY,CAAAA;YACtB,MAAMR,QAAQL,SAAS;gBACnB,WAAWC,OAAO,MAAM;gBACxB,UAAUQ;gBACV,QAAQI,MAAM,KAAK,CAAC,KAAK;YAC7B;YACA,OAAO;gBACH,GAAGA,KAAK;gBACR,OAAOR,SAASQ,MAAM,KAAK,CAAC,KAAK;YACrC;QACJ;IACJ;IAEA,OAAO;QACHJ;QACAE;IACJ;AACJ"}

package/export/crud/imports/importGroups.d.ts

@@ -0,0 +1,8 @@
+import type { CmsContext } from "../../../types/index.js";
+import type { CmsGroupImportResult, ValidCmsGroupResult } from "../../../export/types.js";
+interface Params {
+    context: CmsContext;
+    groups: ValidCmsGroupResult[];
+}
+export declare const importGroups: (params: Params) => Promise<CmsGroupImportResult[]>;
+export {};

package/export/crud/imports/importGroups.js

@@ -0,0 +1,83 @@
+import { CmsImportAction } from "../../types.js";
+const importGroups = async (params)=>{
+    const { context, groups } = params;
+    const results = [];
+    for (const group of groups){
+        if (group.action === CmsImportAction.NONE || group.error) results.push({
+            action: group.action,
+            group: group.group,
+            imported: false,
+            error: group.error || {
+                message: "No action to be ran on the group.",
+                code: "NO_ACTION"
+            }
+        });
+        if (group.action === CmsImportAction.CODE) {
+            results.push({
+                action: group.action,
+                group: group.group,
+                imported: true
+            });
+            continue;
+        }
+        if (group.action === CmsImportAction.UPDATE) {
+            try {
+                const result = await context.cms.updateGroup(group.group.id, {
+                    ...group.group,
+                    icon: group.group.icon ?? void 0,
+                    description: group.group.description || void 0
+                });
+                results.push({
+                    action: group.action,
+                    group: {
+                        ...result
+                    },
+                    imported: true
+                });
+            } catch (ex) {
+                results.push({
+                    action: group.action,
+                    group: group.group,
+                    imported: false,
+                    error: {
+                        message: ex.message,
+                        code: ex.code || "UPDATE_GROUP_ERROR",
+                        data: {
+                            ...ex.data,
+                            group
+                        }
+                    }
+                });
+            }
+            continue;
+        }
+        try {
+            const result = await context.cms.createGroup(group.group);
+            results.push({
+                action: group.action,
+                group: {
+                    ...result
+                },
+                imported: true
+            });
+        } catch (ex) {
+            results.push({
+                action: group.action,
+                group: group.group,
+                imported: false,
+                error: {
+                    message: ex.message,
+                    code: ex.code || "CREATE_GROUP_ERROR",
+                    data: {
+                        ...ex.data,
+                        group
+                    }
+                }
+            });
+        }
+    }
+    return results;
+};
+export { importGroups };
+
+//# sourceMappingURL=importGroups.js.map

package/export/crud/imports/importGroups.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export/crud/imports/importGroups.js","sources":["../../../../src/export/crud/imports/importGroups.ts"],"sourcesContent":["import type { CmsContext } from \"~/types/index.js\";\nimport type { CmsGroupImportResult, ValidCmsGroupResult } from \"~/export/types.js\";\nimport { CmsImportAction } from \"~/export/types.js\";\n\ninterface Params {\n    context: CmsContext;\n    groups: ValidCmsGroupResult[];\n}\n\nexport const importGroups = async (params: Params) => {\n    const { context, groups } = params;\n\n    const results: CmsGroupImportResult[] = [];\n    for (const group of groups) {\n        if (group.action === CmsImportAction.NONE || group.error) {\n            results.push({\n                action: group.action,\n                group: group.group,\n                imported: false,\n                error: group.error || {\n                    message: \"No action to be ran on the group.\",\n                    code: \"NO_ACTION\"\n                }\n            });\n        }\n        /**\n         * Cannot update if the group is created via plugin.\n         */\n        if (group.action === CmsImportAction.CODE) {\n            results.push({\n                action: group.action,\n                group: group.group,\n                imported: true\n            });\n            continue;\n        }\n        /**\n         * Update the group.\n         */\n        //\n        else if (group.action === CmsImportAction.UPDATE) {\n            try {\n                const result = await context.cms.updateGroup(group.group.id, {\n                    ...group.group,\n                    icon: group.group.icon ?? undefined,\n                    description: group.group.description || undefined\n                });\n                results.push({\n                    action: group.action,\n                    group: {\n                        ...result\n                    },\n                    imported: true\n                });\n            } catch (ex) {\n                results.push({\n                    action: group.action,\n                    group: group.group,\n                    imported: false,\n                    error: {\n                        message: ex.message,\n                        code: ex.code || \"UPDATE_GROUP_ERROR\",\n                        data: {\n                            ...ex.data,\n                            group\n                        }\n                    }\n                });\n            }\n            continue;\n        }\n        /**\n         * Create the group\n         */\n        //\n        try {\n            const result = await context.cms.createGroup(group.group);\n            results.push({\n                action: group.action,\n                group: {\n                    ...result\n                },\n                imported: true\n            });\n        } catch (ex) {\n            results.push({\n                action: group.action,\n                group: group.group,\n                imported: false,\n                error: {\n                    message: ex.message,\n                    code: ex.code || \"CREATE_GROUP_ERROR\",\n                    data: {\n                        ...ex.data,\n                        group\n                    }\n                }\n            });\n        }\n    }\n\n    return results;\n};\n"],"names":["importGroups","params","context","groups","results","group","CmsImportAction","result","undefined","ex"],"mappings":";AASO,MAAMA,eAAe,OAAOC;IAC/B,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGF;IAE5B,MAAMG,UAAkC,EAAE;IAC1C,KAAK,MAAMC,SAASF,OAAQ;QACxB,IAAIE,MAAM,MAAM,KAAKC,gBAAgB,IAAI,IAAID,MAAM,KAAK,EACpDD,QAAQ,IAAI,CAAC;YACT,QAAQC,MAAM,MAAM;YACpB,OAAOA,MAAM,KAAK;YAClB,UAAU;YACV,OAAOA,MAAM,KAAK,IAAI;gBAClB,SAAS;gBACT,MAAM;YACV;QACJ;QAKJ,IAAIA,MAAM,MAAM,KAAKC,gBAAgB,IAAI,EAAE;YACvCF,QAAQ,IAAI,CAAC;gBACT,QAAQC,MAAM,MAAM;gBACpB,OAAOA,MAAM,KAAK;gBAClB,UAAU;YACd;YACA;QACJ;QAKK,IAAIA,MAAM,MAAM,KAAKC,gBAAgB,MAAM,EAAE;YAC9C,IAAI;gBACA,MAAMC,SAAS,MAAML,QAAQ,GAAG,CAAC,WAAW,CAACG,MAAM,KAAK,CAAC,EAAE,EAAE;oBACzD,GAAGA,MAAM,KAAK;oBACd,MAAMA,MAAM,KAAK,CAAC,IAAI,IAAIG;oBAC1B,aAAaH,MAAM,KAAK,CAAC,WAAW,IAAIG;gBAC5C;gBACAJ,QAAQ,IAAI,CAAC;oBACT,QAAQC,MAAM,MAAM;oBACpB,OAAO;wBACH,GAAGE,MAAM;oBACb;oBACA,UAAU;gBACd;YACJ,EAAE,OAAOE,IAAI;gBACTL,QAAQ,IAAI,CAAC;oBACT,QAAQC,MAAM,MAAM;oBACpB,OAAOA,MAAM,KAAK;oBAClB,UAAU;oBACV,OAAO;wBACH,SAASI,GAAG,OAAO;wBACnB,MAAMA,GAAG,IAAI,IAAI;wBACjB,MAAM;4BACF,GAAGA,GAAG,IAAI;4BACVJ;wBACJ;oBACJ;gBACJ;YACJ;YACA;QACJ;QAKA,IAAI;YACA,MAAME,SAAS,MAAML,QAAQ,GAAG,CAAC,WAAW,CAACG,MAAM,KAAK;YACxDD,QAAQ,IAAI,CAAC;gBACT,QAAQC,MAAM,MAAM;gBACpB,OAAO;oBACH,GAAGE,MAAM;gBACb;gBACA,UAAU;YACd;QACJ,EAAE,OAAOE,IAAI;YACTL,QAAQ,IAAI,CAAC;gBACT,QAAQC,MAAM,MAAM;gBACpB,OAAOA,MAAM,KAAK;gBAClB,UAAU;gBACV,OAAO;oBACH,SAASI,GAAG,OAAO;oBACnB,MAAMA,GAAG,IAAI,IAAI;oBACjB,MAAM;wBACF,GAAGA,GAAG,IAAI;wBACVJ;oBACJ;gBACJ;YACJ;QACJ;IACJ;IAEA,OAAOD;AACX"}

package/export/crud/imports/importModels.d.ts

@@ -0,0 +1,8 @@
+import type { CmsContext } from "../../../types/index.js";
+import type { CmsModelImportResult, ValidCmsModelResult } from "../../../export/types.js";
+interface Params {
+    context: CmsContext;
+    models: ValidCmsModelResult[];
+}
+export declare const importModels: (params: Params) => Promise<CmsModelImportResult[]>;
+export {};

package/export/crud/imports/importModels.js

@@ -0,0 +1,108 @@
+import { CmsImportAction } from "../../types.js";
+const importModels = async (params)=>{
+    const { context, models } = params;
+    const groups = await context.cms.listGroups();
+    const results = [];
+    for (const model of models){
+        const group = groups.find((group)=>group.slug === model.model.group);
+        if (!group) {
+            results.push({
+                action: model.action,
+                model: model.model,
+                related: model.related,
+                imported: false,
+                error: {
+                    message: `Group "${model.model.group}" does not exist.`,
+                    code: "GROUP_NOT_FOUND",
+                    data: {
+                        model
+                    }
+                }
+            });
+            continue;
+        }
+        if (model.action === CmsImportAction.NONE || model.error) {
+            results.push({
+                action: model.action,
+                model: model.model,
+                related: model.related,
+                imported: false,
+                error: model.error || {
+                    message: "No action to be ran on the model.",
+                    code: "NO_ACTION"
+                }
+            });
+            continue;
+        }
+        if (model.action === CmsImportAction.CODE) {
+            results.push({
+                action: model.action,
+                model: model.model,
+                related: model.related,
+                imported: true
+            });
+            continue;
+        }
+        if (model.action === CmsImportAction.UPDATE) {
+            try {
+                const result = await context.cms.updateModel(model.model.modelId, model.model);
+                results.push({
+                    action: model.action,
+                    model: {
+                        ...result,
+                        group: group.slug
+                    },
+                    related: model.related,
+                    imported: true
+                });
+            } catch (ex) {
+                results.push({
+                    action: model.action,
+                    model: model.model,
+                    imported: false,
+                    related: model.related,
+                    error: {
+                        message: ex.message,
+                        code: ex.code || "UPDATE_MODEL_ERROR",
+                        data: {
+                            model: model.model,
+                            ...ex.data
+                        }
+                    }
+                });
+            }
+            continue;
+        }
+        try {
+            const result = await context.cms.createModel(model.model);
+            results.push({
+                action: model.action,
+                model: {
+                    ...result,
+                    group: group.slug
+                },
+                related: model.related,
+                imported: true
+            });
+        } catch (ex) {
+            results.push({
+                action: model.action,
+                model: model.model,
+                imported: false,
+                related: model.related,
+                error: {
+                    message: ex.message,
+                    code: ex.code || "CREATE_MODEL_ERROR",
+                    data: {
+                        model: model.model,
+                        ...ex.data
+                    }
+                }
+            });
+        }
+    }
+    return results;
+};
+export { importModels };
+
+//# sourceMappingURL=importModels.js.map