@webiny/app-headless-cms 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

package/features/model/cancelDeleteModel/CancelDeleteModelUseCase.js

@@ -0,0 +1,18 @@
+import { CancelDeleteModelRepository, CancelDeleteModelUseCase } from "./abstractions.js";
+class CancelDeleteModelUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(modelId) {
+        return this.repository.execute(modelId);
+    }
+}
+const CancelDeleteModelUseCase_CancelDeleteModelUseCase = CancelDeleteModelUseCase.createImplementation({
+    implementation: CancelDeleteModelUseCaseImpl,
+    dependencies: [
+        CancelDeleteModelRepository
+    ]
+});
+export { CancelDeleteModelUseCase_CancelDeleteModelUseCase as CancelDeleteModelUseCase };
+
+//# sourceMappingURL=CancelDeleteModelUseCase.js.map

package/features/model/cancelDeleteModel/CancelDeleteModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cancelDeleteModel/CancelDeleteModelUseCase.js","sources":["../../../../src/features/model/cancelDeleteModel/CancelDeleteModelUseCase.ts"],"sourcesContent":["import {\n    CancelDeleteModelUseCase as UseCaseAbstraction,\n    CancelDeleteModelRepository\n} from \"./abstractions.js\";\n\nclass CancelDeleteModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: CancelDeleteModelRepository.Interface) {}\n\n    async execute(modelId: string) {\n        return this.repository.execute(modelId);\n    }\n}\n\nexport const CancelDeleteModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CancelDeleteModelUseCaseImpl,\n    dependencies: [CancelDeleteModelRepository]\n});\n"],"names":["CancelDeleteModelUseCaseImpl","repository","modelId","CancelDeleteModelUseCase","UseCaseAbstraction","CancelDeleteModelRepository"],"mappings":";AAKA,MAAMA;IACF,YAAoBC,UAAiD,CAAE;aAAnDA,UAAU,GAAVA;IAAoD;IAExE,MAAM,QAAQC,OAAe,EAAE;QAC3B,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,oDAA2BC,yBAAAA,oBAAuC,CAAC;IAC5E,gBAAgBJ;IAChB,cAAc;QAACK;KAA4B;AAC/C"}

package/features/model/cancelDeleteModel/abstractions.d.ts

@@ -0,0 +1,21 @@
+export interface ICancelDeleteModelGateway {
+    execute(modelId: string): Promise<void>;
+}
+export declare const CancelDeleteModelGateway: import("@webiny/di").Abstraction<ICancelDeleteModelGateway>;
+export declare namespace CancelDeleteModelGateway {
+    type Interface = ICancelDeleteModelGateway;
+}
+export interface ICancelDeleteModelRepository {
+    execute(modelId: string): Promise<void>;
+}
+export declare const CancelDeleteModelRepository: import("@webiny/di").Abstraction<ICancelDeleteModelRepository>;
+export declare namespace CancelDeleteModelRepository {
+    type Interface = ICancelDeleteModelRepository;
+}
+export interface ICancelDeleteModelUseCase {
+    execute(modelId: string): Promise<void>;
+}
+export declare const CancelDeleteModelUseCase: import("@webiny/di").Abstraction<ICancelDeleteModelUseCase>;
+export declare namespace CancelDeleteModelUseCase {
+    type Interface = ICancelDeleteModelUseCase;
+}

package/features/model/cancelDeleteModel/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const CancelDeleteModelGateway = createAbstraction("CancelDeleteModelGateway");
+const CancelDeleteModelRepository = createAbstraction("CancelDeleteModelRepository");
+const CancelDeleteModelUseCase = createAbstraction("CancelDeleteModelUseCase");
+export { CancelDeleteModelGateway, CancelDeleteModelRepository, CancelDeleteModelUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/model/cancelDeleteModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cancelDeleteModel/abstractions.js","sources":["../../../../src/features/model/cancelDeleteModel/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface ICancelDeleteModelGateway {\n    execute(modelId: string): Promise<void>;\n}\n\nexport const CancelDeleteModelGateway = createAbstraction<ICancelDeleteModelGateway>(\n    \"CancelDeleteModelGateway\"\n);\n\nexport namespace CancelDeleteModelGateway {\n    export type Interface = ICancelDeleteModelGateway;\n}\n\nexport interface ICancelDeleteModelRepository {\n    execute(modelId: string): Promise<void>;\n}\n\nexport const CancelDeleteModelRepository = createAbstraction<ICancelDeleteModelRepository>(\n    \"CancelDeleteModelRepository\"\n);\n\nexport namespace CancelDeleteModelRepository {\n    export type Interface = ICancelDeleteModelRepository;\n}\n\nexport interface ICancelDeleteModelUseCase {\n    execute(modelId: string): Promise<void>;\n}\n\nexport const CancelDeleteModelUseCase = createAbstraction<ICancelDeleteModelUseCase>(\n    \"CancelDeleteModelUseCase\"\n);\n\nexport namespace CancelDeleteModelUseCase {\n    export type Interface = ICancelDeleteModelUseCase;\n}\n"],"names":["CancelDeleteModelGateway","createAbstraction","CancelDeleteModelRepository","CancelDeleteModelUseCase"],"mappings":";AAMO,MAAMA,2BAA2BC,kBACpC;AAWG,MAAMC,8BAA8BD,kBACvC;AAWG,MAAME,2BAA2BF,kBACpC"}

package/features/model/cancelDeleteModel/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const CancelDeleteModelFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").ICancelDeleteModelUseCase;
+}, []>;

package/features/model/cancelDeleteModel/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CancelDeleteModelUseCase } from "./abstractions.js";
+import { CancelDeleteModelUseCase as external_CancelDeleteModelUseCase_js_CancelDeleteModelUseCase } from "./CancelDeleteModelUseCase.js";
+import { CancelDeleteModelRepository } from "./CancelDeleteModelRepository.js";
+import { CancelDeleteModelGateway } from "./CancelDeleteModelGateway.js";
+const CancelDeleteModelFeature = createFeature({
+    name: "CmsModel/CancelDeleteModel",
+    register (container) {
+        container.register(external_CancelDeleteModelUseCase_js_CancelDeleteModelUseCase);
+        container.register(CancelDeleteModelRepository).inSingletonScope();
+        container.register(CancelDeleteModelGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CancelDeleteModelUseCase)
+        };
+    }
+});
+export { CancelDeleteModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/cancelDeleteModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cancelDeleteModel/feature.js","sources":["../../../../src/features/model/cancelDeleteModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CancelDeleteModelUseCase as UseCase } from \"./abstractions.js\";\nimport { CancelDeleteModelUseCase } from \"./CancelDeleteModelUseCase.js\";\nimport { CancelDeleteModelRepository } from \"./CancelDeleteModelRepository.js\";\nimport { CancelDeleteModelGateway } from \"./CancelDeleteModelGateway.js\";\n\nexport const CancelDeleteModelFeature = createFeature({\n    name: \"CmsModel/CancelDeleteModel\",\n    register(container) {\n        container.register(CancelDeleteModelUseCase);\n        container.register(CancelDeleteModelRepository).inSingletonScope();\n        container.register(CancelDeleteModelGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CancelDeleteModelFeature","createFeature","container","CancelDeleteModelUseCase","CancelDeleteModelRepository","CancelDeleteModelGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,6BAA6B,gBAAgB;QAChEF,UAAU,QAAQ,CAACG,0BAA0B,gBAAgB;IACjE;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/model/cloneModel/CloneModelGateway.d.ts

@@ -0,0 +1,13 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsModel } from "../../../types.js";
+import type { CloneModelParams } from "./abstractions.js";
+import { CloneModelGateway as GatewayAbstraction } from "./abstractions.js";
+declare class CloneModelGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(params: CloneModelParams): Promise<CmsModel>;
+}
+export declare const CloneModelGateway: typeof CloneModelGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICloneModelGateway>;
+};
+export {};

package/features/model/cloneModel/CloneModelGateway.js

@@ -0,0 +1,62 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { CloneModelGateway } from "./abstractions.js";
+const CREATE_CONTENT_MODEL_FROM = `
+    mutation CmsCreateContentModelFrom($modelId: ID!, $data: CmsContentModelCreateFromInput!) {
+        createContentModelFrom(modelId: $modelId, data: $data) {
+            data {
+                description
+                modelId
+                singularApiName
+                pluralApiName
+                name
+                icon
+                savedOn
+                plugin
+                tags
+                fields {
+                    id
+                    type
+                    fieldId
+                }
+                group
+                createdBy {
+                    id
+                    displayName
+                    type
+                }
+                isBeingDeleted
+            }
+            error {
+                message
+                code
+                data
+            }
+        }
+    }
+`;
+class CloneModelGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: CREATE_CONTENT_MODEL_FROM,
+            variables: {
+                modelId: params.modelId,
+                data: params.data
+            }
+        });
+        const { data: result, error } = response.createContentModelFrom;
+        if (!result) throw new Error(error?.message || "Could not clone content model");
+        return result;
+    }
+}
+const CloneModelGateway_CloneModelGateway = CloneModelGateway.createImplementation({
+    implementation: CloneModelGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { CloneModelGateway_CloneModelGateway as CloneModelGateway };
+
+//# sourceMappingURL=CloneModelGateway.js.map

package/features/model/cloneModel/CloneModelGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cloneModel/CloneModelGateway.js","sources":["../../../../src/features/model/cloneModel/CloneModelGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsModel, CmsErrorResponse } from \"~/types.js\";\nimport type { CloneModelParams } from \"./abstractions.js\";\nimport { CloneModelGateway as GatewayAbstraction } from \"./abstractions.js\";\n\ninterface CloneModelResponse {\n    createContentModelFrom: {\n        data: CmsModel | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\ninterface CloneModelVariables {\n    modelId: string;\n    data: CloneModelParams[\"data\"];\n}\n\nconst CREATE_CONTENT_MODEL_FROM = /* GraphQL */ `\n    mutation CmsCreateContentModelFrom($modelId: ID!, $data: CmsContentModelCreateFromInput!) {\n        createContentModelFrom(modelId: $modelId, data: $data) {\n            data {\n                description\n                modelId\n                singularApiName\n                pluralApiName\n                name\n                icon\n                savedOn\n                plugin\n                tags\n                fields {\n                    id\n                    type\n                    fieldId\n                }\n                group\n                createdBy {\n                    id\n                    displayName\n                    type\n                }\n                isBeingDeleted\n            }\n            error {\n                message\n                code\n                data\n            }\n        }\n    }\n`;\n\nclass CloneModelGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute(params: CloneModelParams) {\n        const response = await this.client.execute<CloneModelResponse, CloneModelVariables>({\n            query: CREATE_CONTENT_MODEL_FROM,\n            variables: { modelId: params.modelId, data: params.data }\n        });\n\n        const { data: result, error } = response.createContentModelFrom;\n\n        if (!result) {\n            throw new Error(error?.message || \"Could not clone content model\");\n        }\n\n        return result;\n    }\n}\n\nexport const CloneModelGateway = GatewayAbstraction.createImplementation({\n    implementation: CloneModelGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["CREATE_CONTENT_MODEL_FROM","CloneModelGatewayImpl","client","params","response","result","error","Error","CloneModelGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;AAiBA,MAAMA,4BAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCjD,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQC,MAAwB,EAAE;QACpC,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA0C;YAChF,OAAOJ;YACP,WAAW;gBAAE,SAASG,OAAO,OAAO;gBAAE,MAAMA,OAAO,IAAI;YAAC;QAC5D;QAEA,MAAM,EAAE,MAAME,MAAM,EAAEC,KAAK,EAAE,GAAGF,SAAS,sBAAsB;QAE/D,IAAI,CAACC,QACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBR;IAChB,cAAc;QAACS;KAAiB;AACpC"}

package/features/model/cloneModel/CloneModelRepository.d.ts

@@ -0,0 +1,13 @@
+import { CloneModelRepository as RepositoryAbstraction, CloneModelGateway } from "./abstractions.js";
+import type { CloneModelParams } from "./abstractions.js";
+import { ModelsCache } from "../../../features/model/abstractions.js";
+declare class CloneModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cache;
+    private gateway;
+    constructor(cache: ModelsCache.Interface, gateway: CloneModelGateway.Interface);
+    execute(params: CloneModelParams): Promise<import("@webiny/app-headless-cms-common/types/model.js").CmsModel>;
+}
+export declare const CloneModelRepository: typeof CloneModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICloneModelRepository>;
+};
+export {};

package/features/model/cloneModel/CloneModelRepository.js

@@ -0,0 +1,25 @@
+import { CloneModelGateway, CloneModelRepository } from "./abstractions.js";
+import { ModelsCache } from "../abstractions.js";
+class CloneModelRepositoryImpl {
+    constructor(cache, gateway){
+        this.cache = cache;
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        const model = await this.gateway.execute(params);
+        this.cache.addItems([
+            model
+        ]);
+        return model;
+    }
+}
+const CloneModelRepository_CloneModelRepository = CloneModelRepository.createImplementation({
+    implementation: CloneModelRepositoryImpl,
+    dependencies: [
+        ModelsCache,
+        CloneModelGateway
+    ]
+});
+export { CloneModelRepository_CloneModelRepository as CloneModelRepository };
+
+//# sourceMappingURL=CloneModelRepository.js.map

package/features/model/cloneModel/CloneModelRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cloneModel/CloneModelRepository.js","sources":["../../../../src/features/model/cloneModel/CloneModelRepository.ts"],"sourcesContent":["import {\n    CloneModelRepository as RepositoryAbstraction,\n    CloneModelGateway\n} from \"./abstractions.js\";\nimport type { CloneModelParams } from \"./abstractions.js\";\nimport { ModelsCache } from \"~/features/model/abstractions.js\";\n\nclass CloneModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cache: ModelsCache.Interface,\n        private gateway: CloneModelGateway.Interface\n    ) {}\n\n    async execute(params: CloneModelParams) {\n        const model = await this.gateway.execute(params);\n        this.cache.addItems([model]);\n        return model;\n    }\n}\n\nexport const CloneModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: CloneModelRepositoryImpl,\n    dependencies: [ModelsCache, CloneModelGateway]\n});\n"],"names":["CloneModelRepositoryImpl","cache","gateway","params","model","CloneModelRepository","RepositoryAbstraction","ModelsCache","CloneModelGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,KAA4B,EAC5BC,OAAoC,CAC9C;aAFUD,KAAK,GAALA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAAwB,EAAE;QACpC,MAAMC,QAAQ,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QACzC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;YAACC;SAAM;QAC3B,OAAOA;IACX;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAA0C,CAAC;IAC3E,gBAAgBN;IAChB,cAAc;QAACO;QAAaC;KAAkB;AAClD"}

package/features/model/cloneModel/CloneModelUseCase.d.ts

@@ -0,0 +1,11 @@
+import { CloneModelUseCase as UseCaseAbstraction, CloneModelRepository } from "./abstractions.js";
+import type { CloneModelParams } from "./abstractions.js";
+declare class CloneModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: CloneModelRepository.Interface);
+    execute(params: CloneModelParams): Promise<import("@webiny/app-headless-cms-common/types/model.js").CmsModel>;
+}
+export declare const CloneModelUseCase: typeof CloneModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICloneModelUseCase>;
+};
+export {};

package/features/model/cloneModel/CloneModelUseCase.js

@@ -0,0 +1,18 @@
+import { CloneModelRepository, CloneModelUseCase } from "./abstractions.js";
+class CloneModelUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(params) {
+        return this.repository.execute(params);
+    }
+}
+const CloneModelUseCase_CloneModelUseCase = CloneModelUseCase.createImplementation({
+    implementation: CloneModelUseCaseImpl,
+    dependencies: [
+        CloneModelRepository
+    ]
+});
+export { CloneModelUseCase_CloneModelUseCase as CloneModelUseCase };
+
+//# sourceMappingURL=CloneModelUseCase.js.map

package/features/model/cloneModel/CloneModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cloneModel/CloneModelUseCase.js","sources":["../../../../src/features/model/cloneModel/CloneModelUseCase.ts"],"sourcesContent":["import { CloneModelUseCase as UseCaseAbstraction, CloneModelRepository } from \"./abstractions.js\";\nimport type { CloneModelParams } from \"./abstractions.js\";\n\nclass CloneModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: CloneModelRepository.Interface) {}\n\n    async execute(params: CloneModelParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const CloneModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CloneModelUseCaseImpl,\n    dependencies: [CloneModelRepository]\n});\n"],"names":["CloneModelUseCaseImpl","repository","params","CloneModelUseCase","UseCaseAbstraction","CloneModelRepository"],"mappings":";AAGA,MAAMA;IACF,YAAoBC,UAA0C,CAAE;aAA5CA,UAAU,GAAVA;IAA6C;IAEjE,MAAM,QAAQC,MAAwB,EAAE;QACpC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBJ;IAChB,cAAc;QAACK;KAAqB;AACxC"}

package/features/model/cloneModel/abstractions.d.ts

@@ -0,0 +1,34 @@
+import type { CmsModel } from "../../../types.js";
+export interface CloneModelParams {
+    modelId: string;
+    data: {
+        name: string;
+        singularApiName?: string;
+        pluralApiName?: string;
+        group?: string;
+        icon?: string;
+        description?: string;
+    };
+}
+export interface ICloneModelGateway {
+    execute(params: CloneModelParams): Promise<CmsModel>;
+}
+export declare const CloneModelGateway: import("@webiny/di").Abstraction<ICloneModelGateway>;
+export declare namespace CloneModelGateway {
+    type Interface = ICloneModelGateway;
+}
+export interface ICloneModelRepository {
+    execute(params: CloneModelParams): Promise<CmsModel>;
+}
+export declare const CloneModelRepository: import("@webiny/di").Abstraction<ICloneModelRepository>;
+export declare namespace CloneModelRepository {
+    type Interface = ICloneModelRepository;
+}
+export interface ICloneModelUseCase {
+    execute(params: CloneModelParams): Promise<CmsModel>;
+}
+export declare const CloneModelUseCase: import("@webiny/di").Abstraction<ICloneModelUseCase>;
+export declare namespace CloneModelUseCase {
+    type Interface = ICloneModelUseCase;
+    type Params = CloneModelParams;
+}

package/features/model/cloneModel/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const CloneModelGateway = createAbstraction("CloneModelGateway");
+const CloneModelRepository = createAbstraction("CloneModelRepository");
+const CloneModelUseCase = createAbstraction("CloneModelUseCase");
+export { CloneModelGateway, CloneModelRepository, CloneModelUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/model/cloneModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cloneModel/abstractions.js","sources":["../../../../src/features/model/cloneModel/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsModel } from \"~/types.js\";\n\nexport interface CloneModelParams {\n    modelId: string;\n    data: {\n        name: string;\n        singularApiName?: string;\n        pluralApiName?: string;\n        group?: string;\n        icon?: string;\n        description?: string;\n    };\n}\n\nexport interface ICloneModelGateway {\n    execute(params: CloneModelParams): Promise<CmsModel>;\n}\n\nexport const CloneModelGateway = createAbstraction<ICloneModelGateway>(\"CloneModelGateway\");\n\nexport namespace CloneModelGateway {\n    export type Interface = ICloneModelGateway;\n}\n\nexport interface ICloneModelRepository {\n    execute(params: CloneModelParams): Promise<CmsModel>;\n}\n\nexport const CloneModelRepository =\n    createAbstraction<ICloneModelRepository>(\"CloneModelRepository\");\n\nexport namespace CloneModelRepository {\n    export type Interface = ICloneModelRepository;\n}\n\nexport interface ICloneModelUseCase {\n    execute(params: CloneModelParams): Promise<CmsModel>;\n}\n\nexport const CloneModelUseCase = createAbstraction<ICloneModelUseCase>(\"CloneModelUseCase\");\n\nexport namespace CloneModelUseCase {\n    export type Interface = ICloneModelUseCase;\n    export type Params = CloneModelParams;\n}\n"],"names":["CloneModelGateway","createAbstraction","CloneModelRepository","CloneModelUseCase"],"mappings":";AAmBO,MAAMA,oBAAoBC,kBAAsC;AAUhE,MAAMC,uBACTD,kBAAyC;AAUtC,MAAME,oBAAoBF,kBAAsC"}

package/features/model/cloneModel/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const CloneModelFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").ICloneModelUseCase;
+}, []>;

package/features/model/cloneModel/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CloneModelUseCase } from "./abstractions.js";
+import { CloneModelUseCase as external_CloneModelUseCase_js_CloneModelUseCase } from "./CloneModelUseCase.js";
+import { CloneModelRepository } from "./CloneModelRepository.js";
+import { CloneModelGateway } from "./CloneModelGateway.js";
+const CloneModelFeature = createFeature({
+    name: "CmsModel/CloneModel",
+    register (container) {
+        container.register(external_CloneModelUseCase_js_CloneModelUseCase);
+        container.register(CloneModelRepository).inSingletonScope();
+        container.register(CloneModelGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CloneModelUseCase)
+        };
+    }
+});
+export { CloneModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/cloneModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/cloneModel/feature.js","sources":["../../../../src/features/model/cloneModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CloneModelUseCase as UseCase } from \"./abstractions.js\";\nimport { CloneModelUseCase } from \"./CloneModelUseCase.js\";\nimport { CloneModelRepository } from \"./CloneModelRepository.js\";\nimport { CloneModelGateway } from \"./CloneModelGateway.js\";\n\nexport const CloneModelFeature = createFeature({\n    name: \"CmsModel/CloneModel\",\n    register(container) {\n        container.register(CloneModelUseCase);\n        container.register(CloneModelRepository).inSingletonScope();\n        container.register(CloneModelGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CloneModelFeature","createFeature","container","CloneModelUseCase","CloneModelRepository","CloneModelGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,sBAAsB,gBAAgB;QACzDF,UAAU,QAAQ,CAACG,mBAAmB,gBAAgB;IAC1D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/model/createModel/CreateModelGateway.d.ts

@@ -0,0 +1,13 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsModel } from "../../../types.js";
+import type { CreateModelParams } from "./abstractions.js";
+import { CreateModelGateway as GatewayAbstraction } from "./abstractions.js";
+declare class CreateModelGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelGateway: typeof CreateModelGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelGateway>;
+};
+export {};

package/features/model/createModel/CreateModelGateway.js

@@ -0,0 +1,61 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { CreateModelGateway } from "./abstractions.js";
+const CREATE_CONTENT_MODEL = `
+    mutation CmsCreateContentModel($data: CmsContentModelCreateInput!) {
+        createContentModel(data: $data) {
+            data {
+                description
+                modelId
+                singularApiName
+                pluralApiName
+                name
+                icon
+                savedOn
+                plugin
+                tags
+                fields {
+                    id
+                    type
+                    fieldId
+                }
+                group
+                createdBy {
+                    id
+                    displayName
+                    type
+                }
+                isBeingDeleted
+            }
+            error {
+                message
+                code
+                data
+            }
+        }
+    }
+`;
+class CreateModelGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(data) {
+        const response = await this.client.execute({
+            query: CREATE_CONTENT_MODEL,
+            variables: {
+                data
+            }
+        });
+        const { data: result, error } = response.createContentModel;
+        if (!result) throw new Error(error?.message || "Could not create content model");
+        return result;
+    }
+}
+const CreateModelGateway_CreateModelGateway = CreateModelGateway.createImplementation({
+    implementation: CreateModelGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { CreateModelGateway_CreateModelGateway as CreateModelGateway };
+
+//# sourceMappingURL=CreateModelGateway.js.map

package/features/model/createModel/CreateModelGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/CreateModelGateway.js","sources":["../../../../src/features/model/createModel/CreateModelGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsModel, CmsErrorResponse } from \"~/types.js\";\nimport type { CreateModelParams } from \"./abstractions.js\";\nimport { CreateModelGateway as GatewayAbstraction } from \"./abstractions.js\";\n\ninterface CreateModelResponse {\n    createContentModel: {\n        data: CmsModel | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\ninterface CreateModelVariables {\n    data: CreateModelParams;\n}\n\nconst CREATE_CONTENT_MODEL = /* GraphQL */ `\n    mutation CmsCreateContentModel($data: CmsContentModelCreateInput!) {\n        createContentModel(data: $data) {\n            data {\n                description\n                modelId\n                singularApiName\n                pluralApiName\n                name\n                icon\n                savedOn\n                plugin\n                tags\n                fields {\n                    id\n                    type\n                    fieldId\n                }\n                group\n                createdBy {\n                    id\n                    displayName\n                    type\n                }\n                isBeingDeleted\n            }\n            error {\n                message\n                code\n                data\n            }\n        }\n    }\n`;\n\nclass CreateModelGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute(data: CreateModelParams) {\n        const response = await this.client.execute<CreateModelResponse, CreateModelVariables>({\n            query: CREATE_CONTENT_MODEL,\n            variables: { data }\n        });\n\n        const { data: result, error } = response.createContentModel;\n\n        if (!result) {\n            throw new Error(error?.message || \"Could not create content model\");\n        }\n\n        return result;\n    }\n}\n\nexport const CreateModelGateway = GatewayAbstraction.createImplementation({\n    implementation: CreateModelGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["CREATE_CONTENT_MODEL","CreateModelGatewayImpl","client","data","response","result","error","Error","CreateModelGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;AAgBA,MAAMA,uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiC5C,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQC,IAAuB,EAAE;QACnC,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA4C;YAClF,OAAOJ;YACP,WAAW;gBAAEG;YAAK;QACtB;QAEA,MAAM,EAAE,MAAME,MAAM,EAAEC,KAAK,EAAE,GAAGF,SAAS,kBAAkB;QAE3D,IAAI,CAACC,QACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBR;IAChB,cAAc;QAACS;KAAiB;AACpC"}

package/features/model/createModel/CreateModelRepository.d.ts

@@ -0,0 +1,13 @@
+import { CreateModelRepository as RepositoryAbstraction, CreateModelGateway } from "./abstractions.js";
+import type { CreateModelParams } from "./abstractions.js";
+import { ModelsCache } from "../../../features/model/abstractions.js";
+declare class CreateModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cache;
+    private gateway;
+    constructor(cache: ModelsCache.Interface, gateway: CreateModelGateway.Interface);
+    execute(data: CreateModelParams): Promise<import("@webiny/app-headless-cms-common/types/model.js").CmsModel>;
+}
+export declare const CreateModelRepository: typeof CreateModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelRepository>;
+};
+export {};

package/features/model/createModel/CreateModelRepository.js

@@ -0,0 +1,25 @@
+import { CreateModelGateway, CreateModelRepository } from "./abstractions.js";
+import { ModelsCache } from "../abstractions.js";
+class CreateModelRepositoryImpl {
+    constructor(cache, gateway){
+        this.cache = cache;
+        this.gateway = gateway;
+    }
+    async execute(data) {
+        const model = await this.gateway.execute(data);
+        this.cache.addItems([
+            model
+        ]);
+        return model;
+    }
+}
+const CreateModelRepository_CreateModelRepository = CreateModelRepository.createImplementation({
+    implementation: CreateModelRepositoryImpl,
+    dependencies: [
+        ModelsCache,
+        CreateModelGateway
+    ]
+});
+export { CreateModelRepository_CreateModelRepository as CreateModelRepository };
+
+//# sourceMappingURL=CreateModelRepository.js.map

package/features/model/createModel/CreateModelRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/CreateModelRepository.js","sources":["../../../../src/features/model/createModel/CreateModelRepository.ts"],"sourcesContent":["import {\n    CreateModelRepository as RepositoryAbstraction,\n    CreateModelGateway\n} from \"./abstractions.js\";\nimport type { CreateModelParams } from \"./abstractions.js\";\nimport { ModelsCache } from \"~/features/model/abstractions.js\";\n\nclass CreateModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cache: ModelsCache.Interface,\n        private gateway: CreateModelGateway.Interface\n    ) {}\n\n    async execute(data: CreateModelParams) {\n        const model = await this.gateway.execute(data);\n        this.cache.addItems([model]);\n        return model;\n    }\n}\n\nexport const CreateModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateModelRepositoryImpl,\n    dependencies: [ModelsCache, CreateModelGateway]\n});\n"],"names":["CreateModelRepositoryImpl","cache","gateway","data","model","CreateModelRepository","RepositoryAbstraction","ModelsCache","CreateModelGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,KAA4B,EAC5BC,OAAqC,CAC/C;aAFUD,KAAK,GAALA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,IAAuB,EAAE;QACnC,MAAMC,QAAQ,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QACzC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;YAACC;SAAM;QAC3B,OAAOA;IACX;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBN;IAChB,cAAc;QAACO;QAAaC;KAAmB;AACnD"}

package/features/model/createModel/CreateModelUseCase.d.ts

@@ -0,0 +1,11 @@
+import { CreateModelUseCase as UseCaseAbstraction, CreateModelRepository } from "./abstractions.js";
+import type { CreateModelParams } from "./abstractions.js";
+declare class CreateModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: CreateModelRepository.Interface);
+    execute(data: CreateModelParams): Promise<import("@webiny/app-headless-cms-common/types/model.js").CmsModel>;
+}
+export declare const CreateModelUseCase: typeof CreateModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelUseCase>;
+};
+export {};

package/features/model/createModel/CreateModelUseCase.js

@@ -0,0 +1,18 @@
+import { CreateModelRepository, CreateModelUseCase } from "./abstractions.js";
+class CreateModelUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(data) {
+        return this.repository.execute(data);
+    }
+}
+const CreateModelUseCase_CreateModelUseCase = CreateModelUseCase.createImplementation({
+    implementation: CreateModelUseCaseImpl,
+    dependencies: [
+        CreateModelRepository
+    ]
+});
+export { CreateModelUseCase_CreateModelUseCase as CreateModelUseCase };
+
+//# sourceMappingURL=CreateModelUseCase.js.map

package/features/model/createModel/CreateModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/CreateModelUseCase.js","sources":["../../../../src/features/model/createModel/CreateModelUseCase.ts"],"sourcesContent":["import { CreateModelUseCase as UseCaseAbstraction, CreateModelRepository } from \"./abstractions.js\";\nimport type { CreateModelParams } from \"./abstractions.js\";\n\nclass CreateModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: CreateModelRepository.Interface) {}\n\n    async execute(data: CreateModelParams) {\n        return this.repository.execute(data);\n    }\n}\n\nexport const CreateModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateModelUseCaseImpl,\n    dependencies: [CreateModelRepository]\n});\n"],"names":["CreateModelUseCaseImpl","repository","data","CreateModelUseCase","UseCaseAbstraction","CreateModelRepository"],"mappings":";AAGA,MAAMA;IACF,YAAoBC,UAA2C,CAAE;aAA7CA,UAAU,GAAVA;IAA8C;IAElE,MAAM,QAAQC,IAAuB,EAAE;QACnC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAsB;AACzC"}

package/features/model/createModel/abstractions.d.ts

@@ -0,0 +1,33 @@
+import type { CmsModel } from "../../../types.js";
+export interface CreateModelParams {
+    name: string;
+    singularApiName: string;
+    pluralApiName?: string;
+    group: string;
+    icon?: string;
+    description?: string;
+    defaultFields?: boolean;
+    tags?: string[];
+}
+export interface ICreateModelGateway {
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelGateway: import("@webiny/di").Abstraction<ICreateModelGateway>;
+export declare namespace CreateModelGateway {
+    type Interface = ICreateModelGateway;
+}
+export interface ICreateModelRepository {
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelRepository: import("@webiny/di").Abstraction<ICreateModelRepository>;
+export declare namespace CreateModelRepository {
+    type Interface = ICreateModelRepository;
+}
+export interface ICreateModelUseCase {
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelUseCase: import("@webiny/di").Abstraction<ICreateModelUseCase>;
+export declare namespace CreateModelUseCase {
+    type Interface = ICreateModelUseCase;
+    type Params = CreateModelParams;
+}

package/features/model/createModel/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const CreateModelGateway = createAbstraction("CreateModelGateway");
+const CreateModelRepository = createAbstraction("CreateModelRepository");
+const CreateModelUseCase = createAbstraction("CreateModelUseCase");
+export { CreateModelGateway, CreateModelRepository, CreateModelUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/model/createModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/abstractions.js","sources":["../../../../src/features/model/createModel/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsModel } from \"~/types.js\";\n\nexport interface CreateModelParams {\n    name: string;\n    singularApiName: string;\n    pluralApiName?: string;\n    group: string;\n    icon?: string;\n    description?: string;\n    defaultFields?: boolean;\n    tags?: string[];\n}\n\nexport interface ICreateModelGateway {\n    execute(data: CreateModelParams): Promise<CmsModel>;\n}\n\nexport const CreateModelGateway = createAbstraction<ICreateModelGateway>(\"CreateModelGateway\");\n\nexport namespace CreateModelGateway {\n    export type Interface = ICreateModelGateway;\n}\n\nexport interface ICreateModelRepository {\n    execute(data: CreateModelParams): Promise<CmsModel>;\n}\n\nexport const CreateModelRepository =\n    createAbstraction<ICreateModelRepository>(\"CreateModelRepository\");\n\nexport namespace CreateModelRepository {\n    export type Interface = ICreateModelRepository;\n}\n\nexport interface ICreateModelUseCase {\n    execute(data: CreateModelParams): Promise<CmsModel>;\n}\n\nexport const CreateModelUseCase = createAbstraction<ICreateModelUseCase>(\"CreateModelUseCase\");\n\nexport namespace CreateModelUseCase {\n    export type Interface = ICreateModelUseCase;\n    export type Params = CreateModelParams;\n}\n"],"names":["CreateModelGateway","createAbstraction","CreateModelRepository","CreateModelUseCase"],"mappings":";AAkBO,MAAMA,qBAAqBC,kBAAuC;AAUlE,MAAMC,wBACTD,kBAA0C;AAUvC,MAAME,qBAAqBF,kBAAuC"}

package/features/model/createModel/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const CreateModelFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").ICreateModelUseCase;
+}, []>;

package/features/model/createModel/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CreateModelUseCase } from "./abstractions.js";
+import { CreateModelUseCase as external_CreateModelUseCase_js_CreateModelUseCase } from "./CreateModelUseCase.js";
+import { CreateModelRepository } from "./CreateModelRepository.js";
+import { CreateModelGateway } from "./CreateModelGateway.js";
+const CreateModelFeature = createFeature({
+    name: "CmsModel/CreateModel",
+    register (container) {
+        container.register(external_CreateModelUseCase_js_CreateModelUseCase);
+        container.register(CreateModelRepository).inSingletonScope();
+        container.register(CreateModelGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CreateModelUseCase)
+        };
+    }
+});
+export { CreateModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/createModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/feature.js","sources":["../../../../src/features/model/createModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CreateModelUseCase as UseCase } from \"./abstractions.js\";\nimport { CreateModelUseCase } from \"./CreateModelUseCase.js\";\nimport { CreateModelRepository } from \"./CreateModelRepository.js\";\nimport { CreateModelGateway } from \"./CreateModelGateway.js\";\n\nexport const CreateModelFeature = createFeature({\n    name: \"CmsModel/CreateModel\",\n    register(container) {\n        container.register(CreateModelUseCase);\n        container.register(CreateModelRepository).inSingletonScope();\n        container.register(CreateModelGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CreateModelFeature","createFeature","container","CreateModelUseCase","CreateModelRepository","CreateModelGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;IAC3D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/model/deleteModel/DeleteModelGateway.d.ts

@@ -0,0 +1,12 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { DeleteModelResult } from "./abstractions.js";
+import { DeleteModelGateway as GatewayAbstraction } from "./abstractions.js";
+declare class DeleteModelGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;
+}
+export declare const DeleteModelGateway: typeof DeleteModelGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelGateway>;
+};
+export {};