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

package/features/contentEntry/refTypes.d.ts

@@ -0,0 +1,44 @@
+export interface CmsReferenceEntry {
+    id: string;
+    entryId: string;
+    status: string;
+    title: string;
+    description: string | null;
+    image: string | null;
+    createdOn: string;
+    savedOn: string;
+    createdBy: {
+        id: string;
+        type: string;
+        displayName: string;
+    };
+    modifiedBy: {
+        id: string;
+        type: string;
+        displayName: string;
+    } | null;
+    model: {
+        modelId: string;
+        name: string;
+    };
+    published: {
+        id: string;
+        entryId: string;
+        title: string;
+    } | null;
+    wbyAco_location: {
+        folderId: string;
+    } | null;
+}
+export interface CmsReferenceValue {
+    id: string;
+    modelId: string;
+}
+/**
+ * A partial update to an already-resolved reference entry, keyed by `entryId`.
+ * Used to patch the in-memory card after editing a referenced entry, avoiding a refetch.
+ */
+export type CmsReferenceEntryPatch = Partial<CmsReferenceEntry> & {
+    entryId: string;
+};
+export declare const REFERENCE_ENTRY_FIELDS = "\n    data {\n        id\n        entryId\n        status\n        title\n        description\n        image\n        createdOn\n        savedOn\n        createdBy {\n            id\n            type\n            displayName\n        }\n        modifiedBy {\n            id\n            type\n            displayName\n        }\n        model {\n            modelId\n            name\n        }\n        published {\n            id\n            entryId\n            title\n        }\n        wbyAco_location {\n            folderId\n        }\n    }\n    error {\n        message\n        code\n        data\n    }\n";

package/features/contentEntry/refTypes.js

@@ -0,0 +1,42 @@
+const REFERENCE_ENTRY_FIELDS = `
+    data {
+        id
+        entryId
+        status
+        title
+        description
+        image
+        createdOn
+        savedOn
+        createdBy {
+            id
+            type
+            displayName
+        }
+        modifiedBy {
+            id
+            type
+            displayName
+        }
+        model {
+            modelId
+            name
+        }
+        published {
+            id
+            entryId
+            title
+        }
+        wbyAco_location {
+            folderId
+        }
+    }
+    error {
+        message
+        code
+        data
+    }
+`;
+export { REFERENCE_ENTRY_FIELDS };
+
+//# sourceMappingURL=refTypes.js.map

package/features/contentEntry/refTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/refTypes.js","sources":["../../../src/features/contentEntry/refTypes.ts"],"sourcesContent":["export interface CmsReferenceEntry {\n    id: string;\n    entryId: string;\n    status: string;\n    title: string;\n    description: string | null;\n    image: string | null;\n    createdOn: string;\n    savedOn: string;\n    createdBy: { id: string; type: string; displayName: string };\n    modifiedBy: { id: string; type: string; displayName: string } | null;\n    model: { modelId: string; name: string };\n    published: { id: string; entryId: string; title: string } | null;\n    wbyAco_location: { folderId: string } | null;\n}\n\nexport interface CmsReferenceValue {\n    id: string;\n    modelId: string;\n}\n\n/**\n * A partial update to an already-resolved reference entry, keyed by `entryId`.\n * Used to patch the in-memory card after editing a referenced entry, avoiding a refetch.\n */\nexport type CmsReferenceEntryPatch = Partial<CmsReferenceEntry> & { entryId: string };\n\nexport const REFERENCE_ENTRY_FIELDS = /* GraphQL */ `\n    data {\n        id\n        entryId\n        status\n        title\n        description\n        image\n        createdOn\n        savedOn\n        createdBy {\n            id\n            type\n            displayName\n        }\n        modifiedBy {\n            id\n            type\n            displayName\n        }\n        model {\n            modelId\n            name\n        }\n        published {\n            id\n            entryId\n            title\n        }\n        wbyAco_location {\n            folderId\n        }\n    }\n    error {\n        message\n        code\n        data\n    }\n`;\n"],"names":["REFERENCE_ENTRY_FIELDS"],"mappings":"AA2BO,MAAMA,yBAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCrD,CAAC"}

package/features/contentEntry/restoreFromTrash/RestoreFromTrashGateway.d.ts

@@ -0,0 +1,14 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { RestoreFromTrashGateway as GatewayAbstraction, type IRestoreFromTrashParams } from "./abstractions.js";
+declare class RestoreFromTrashGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private fields;
+    constructor(client: CmsGraphQLClient.Interface, fields: EntryGraphQLFields.Interface);
+    execute({ model, id }: IRestoreFromTrashParams): Promise<CmsContentEntry>;
+}
+export declare const RestoreFromTrashGateway: typeof RestoreFromTrashGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRestoreFromTrashGateway>;
+};
+export {};

package/features/contentEntry/restoreFromTrash/RestoreFromTrashGateway.js

@@ -0,0 +1,43 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { RestoreFromTrashGateway } from "./abstractions.js";
+function createMutation(model, fields) {
+    return `
+        mutation CmsEntriesRestore${model.singularApiName}FromBin($revision: ID!) {
+            content: restore${model.singularApiName}FromBin(revision: $revision) {
+                data {
+                    ${fields.getSystemFields(model)}
+                    ${fields.getValuesBlock(model)}
+                }
+                error { message code data }
+            }
+        }
+    `;
+}
+class RestoreFromTrashGatewayImpl {
+    constructor(client, fields){
+        this.client = client;
+        this.fields = fields;
+    }
+    async execute({ model, id }) {
+        const response = await this.client.execute({
+            query: createMutation(model, this.fields),
+            variables: {
+                revision: id
+            }
+        });
+        const { data, error } = response.content;
+        if (!data) throw new Error(error?.message || "Could not restore the entry from trash bin.");
+        return data;
+    }
+}
+const RestoreFromTrashGateway_RestoreFromTrashGateway = RestoreFromTrashGateway.createImplementation({
+    implementation: RestoreFromTrashGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient,
+        EntryGraphQLFields
+    ]
+});
+export { RestoreFromTrashGateway_RestoreFromTrashGateway as RestoreFromTrashGateway };
+
+//# sourceMappingURL=RestoreFromTrashGateway.js.map

package/features/contentEntry/restoreFromTrash/RestoreFromTrashGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/restoreFromTrash/RestoreFromTrashGateway.js","sources":["../../../../src/features/contentEntry/restoreFromTrash/RestoreFromTrashGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    RestoreFromTrashGateway as GatewayAbstraction,\n    type IRestoreFromTrashParams\n} from \"./abstractions.js\";\n\ninterface RestoreEntryResponse {\n    content: {\n        data: CmsContentEntry | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nfunction createMutation(model: CmsModel, fields: EntryGraphQLFields.Interface) {\n    return /* GraphQL */ `\n        mutation CmsEntriesRestore${model.singularApiName}FromBin($revision: ID!) {\n            content: restore${model.singularApiName}FromBin(revision: $revision) {\n                data {\n                    ${fields.getSystemFields(model)}\n                    ${fields.getValuesBlock(model)}\n                }\n                error { message code data }\n            }\n        }\n    `;\n}\n\nclass RestoreFromTrashGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model, id }: IRestoreFromTrashParams): Promise<CmsContentEntry> {\n        const response = await this.client.execute<RestoreEntryResponse>({\n            query: createMutation(model, this.fields),\n            variables: { revision: id }\n        });\n\n        const { data, error } = response.content;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not restore the entry from trash bin.\");\n        }\n\n        return data;\n    }\n}\n\nexport const RestoreFromTrashGateway = GatewayAbstraction.createImplementation({\n    implementation: RestoreFromTrashGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryGraphQLFields]\n});\n"],"names":["createMutation","model","fields","RestoreFromTrashGatewayImpl","client","id","response","data","error","Error","RestoreFromTrashGateway","GatewayAbstraction","CmsGraphQLClient","EntryGraphQLFields"],"mappings":";;;AAeA,SAASA,eAAeC,KAAe,EAAEC,MAAoC;IACzE,OAAqB,CAAC;kCACQ,EAAED,MAAM,eAAe,CAAC;4BAC9B,EAAEA,MAAM,eAAe,CAAC;;oBAEhC,EAAEC,OAAO,eAAe,CAACD,OAAO;oBAChC,EAAEC,OAAO,cAAc,CAACD,OAAO;;;;;IAK/C,CAAC;AACL;AAEA,MAAME;IACF,YACYC,MAAkC,EAClCF,MAAoC,CAC9C;aAFUE,MAAM,GAANA;aACAF,MAAM,GAANA;IACT;IAEH,MAAM,QAAQ,EAAED,KAAK,EAAEI,EAAE,EAA2B,EAA4B;QAC5E,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAuB;YAC7D,OAAON,eAAeC,OAAO,IAAI,CAAC,MAAM;YACxC,WAAW;gBAAE,UAAUI;YAAG;QAC9B;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAExC,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,kDAA0BC,wBAAAA,oBAAuC,CAAC;IAC3E,gBAAgBR;IAChB,cAAc;QAACS;QAAkBC;KAAmB;AACxD"}

package/features/contentEntry/restoreFromTrash/RestoreFromTrashRepository.d.ts

@@ -0,0 +1,13 @@
+import { RestoreFromTrashRepository as RepositoryAbstraction, RestoreFromTrashGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../../../features/contentEntry/abstractions.js";
+import type { IRestoreFromTrashParams } from "./abstractions.js";
+declare class RestoreFromTrashRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cacheProvider;
+    private gateway;
+    constructor(cacheProvider: ContentEntriesCacheProvider.Interface, gateway: RestoreFromTrashGateway.Interface);
+    execute(params: IRestoreFromTrashParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const RestoreFromTrashRepository: typeof RestoreFromTrashRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRestoreFromTrashRepository>;
+};
+export {};

package/features/contentEntry/restoreFromTrash/RestoreFromTrashRepository.js

@@ -0,0 +1,26 @@
+import { RestoreFromTrashGateway, RestoreFromTrashRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+class RestoreFromTrashRepositoryImpl {
+    constructor(cacheProvider, gateway){
+        this.cacheProvider = cacheProvider;
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        const entry = await this.gateway.execute(params);
+        const cache = this.cacheProvider.get(params.model.modelId);
+        cache.addItems([
+            entry
+        ]);
+        return entry;
+    }
+}
+const RestoreFromTrashRepository_RestoreFromTrashRepository = RestoreFromTrashRepository.createImplementation({
+    implementation: RestoreFromTrashRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        RestoreFromTrashGateway
+    ]
+});
+export { RestoreFromTrashRepository_RestoreFromTrashRepository as RestoreFromTrashRepository };
+
+//# sourceMappingURL=RestoreFromTrashRepository.js.map

package/features/contentEntry/restoreFromTrash/RestoreFromTrashRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/restoreFromTrash/RestoreFromTrashRepository.js","sources":["../../../../src/features/contentEntry/restoreFromTrash/RestoreFromTrashRepository.ts"],"sourcesContent":["import {\n    RestoreFromTrashRepository as RepositoryAbstraction,\n    RestoreFromTrashGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { IRestoreFromTrashParams } from \"./abstractions.js\";\n\nclass RestoreFromTrashRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: RestoreFromTrashGateway.Interface\n    ) {}\n\n    async execute(params: IRestoreFromTrashParams) {\n        const entry = await this.gateway.execute(params);\n\n        const cache = this.cacheProvider.get(params.model.modelId);\n        cache.addItems([entry]);\n\n        return entry;\n    }\n}\n\nexport const RestoreFromTrashRepository = RepositoryAbstraction.createImplementation({\n    implementation: RestoreFromTrashRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, RestoreFromTrashGateway]\n});\n"],"names":["RestoreFromTrashRepositoryImpl","cacheProvider","gateway","params","entry","cache","RestoreFromTrashRepository","RepositoryAbstraction","ContentEntriesCacheProvider","RestoreFromTrashGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAA0C,CACpD;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAA+B,EAAE;QAC3C,MAAMC,QAAQ,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QAEzC,MAAME,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACF,OAAO,KAAK,CAAC,OAAO;QACzDE,MAAM,QAAQ,CAAC;YAACD;SAAM;QAEtB,OAAOA;IACX;AACJ;AAEO,MAAME,wDAA6BC,2BAAAA,oBAA0C,CAAC;IACjF,gBAAgBP;IAChB,cAAc;QAACQ;QAA6BC;KAAwB;AACxE"}

package/features/contentEntry/restoreFromTrash/RestoreFromTrashUseCase.d.ts

@@ -0,0 +1,11 @@
+import { RestoreFromTrashUseCase as UseCaseAbstraction, RestoreFromTrashRepository } from "./abstractions.js";
+import type { IRestoreFromTrashParams } from "./abstractions.js";
+declare class RestoreFromTrashUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: RestoreFromTrashRepository.Interface);
+    execute(params: IRestoreFromTrashParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const RestoreFromTrashUseCase: typeof RestoreFromTrashUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRestoreFromTrashUseCase>;
+};
+export {};

package/features/contentEntry/restoreFromTrash/RestoreFromTrashUseCase.js

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

package/features/contentEntry/restoreFromTrash/RestoreFromTrashUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/restoreFromTrash/RestoreFromTrashUseCase.js","sources":["../../../../src/features/contentEntry/restoreFromTrash/RestoreFromTrashUseCase.ts"],"sourcesContent":["import {\n    RestoreFromTrashUseCase as UseCaseAbstraction,\n    RestoreFromTrashRepository\n} from \"./abstractions.js\";\nimport type { IRestoreFromTrashParams } from \"./abstractions.js\";\n\nclass RestoreFromTrashUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: RestoreFromTrashRepository.Interface) {}\n\n    async execute(params: IRestoreFromTrashParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const RestoreFromTrashUseCase = UseCaseAbstraction.createImplementation({\n    implementation: RestoreFromTrashUseCaseImpl,\n    dependencies: [RestoreFromTrashRepository]\n});\n"],"names":["RestoreFromTrashUseCaseImpl","repository","params","RestoreFromTrashUseCase","UseCaseAbstraction","RestoreFromTrashRepository"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,UAAgD,CAAE;aAAlDA,UAAU,GAAVA;IAAmD;IAEvE,MAAM,QAAQC,MAA+B,EAAE;QAC3C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAAuC,CAAC;IAC3E,gBAAgBJ;IAChB,cAAc;QAACK;KAA2B;AAC9C"}

package/features/contentEntry/restoreFromTrash/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface IRestoreFromTrashParams {
+    model: CmsModel;
+    id: string;
+}
+export interface IRestoreFromTrashGateway {
+    execute(params: IRestoreFromTrashParams): Promise<CmsContentEntry>;
+}
+export declare const RestoreFromTrashGateway: import("@webiny/di").Abstraction<IRestoreFromTrashGateway>;
+export declare namespace RestoreFromTrashGateway {
+    type Interface = IRestoreFromTrashGateway;
+}
+export interface IRestoreFromTrashRepository {
+    execute(params: IRestoreFromTrashParams): Promise<CmsContentEntry>;
+}
+export declare const RestoreFromTrashRepository: import("@webiny/di").Abstraction<IRestoreFromTrashRepository>;
+export declare namespace RestoreFromTrashRepository {
+    type Interface = IRestoreFromTrashRepository;
+}
+export interface IRestoreFromTrashUseCase {
+    execute(params: IRestoreFromTrashParams): Promise<CmsContentEntry>;
+}
+export declare const RestoreFromTrashUseCase: import("@webiny/di").Abstraction<IRestoreFromTrashUseCase>;
+export declare namespace RestoreFromTrashUseCase {
+    type Interface = IRestoreFromTrashUseCase;
+}

package/features/contentEntry/restoreFromTrash/abstractions.js

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

package/features/contentEntry/restoreFromTrash/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/restoreFromTrash/abstractions.js","sources":["../../../../src/features/contentEntry/restoreFromTrash/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface IRestoreFromTrashParams {\n    model: CmsModel;\n    id: string;\n}\n\nexport interface IRestoreFromTrashGateway {\n    execute(params: IRestoreFromTrashParams): Promise<CmsContentEntry>;\n}\n\nexport const RestoreFromTrashGateway =\n    createAbstraction<IRestoreFromTrashGateway>(\"RestoreFromTrashGateway\");\n\nexport namespace RestoreFromTrashGateway {\n    export type Interface = IRestoreFromTrashGateway;\n}\n\nexport interface IRestoreFromTrashRepository {\n    execute(params: IRestoreFromTrashParams): Promise<CmsContentEntry>;\n}\n\nexport const RestoreFromTrashRepository = createAbstraction<IRestoreFromTrashRepository>(\n    \"RestoreFromTrashRepository\"\n);\n\nexport namespace RestoreFromTrashRepository {\n    export type Interface = IRestoreFromTrashRepository;\n}\n\nexport interface IRestoreFromTrashUseCase {\n    execute(params: IRestoreFromTrashParams): Promise<CmsContentEntry>;\n}\n\nexport const RestoreFromTrashUseCase =\n    createAbstraction<IRestoreFromTrashUseCase>(\"RestoreFromTrashUseCase\");\n\nexport namespace RestoreFromTrashUseCase {\n    export type Interface = IRestoreFromTrashUseCase;\n}\n"],"names":["RestoreFromTrashGateway","createAbstraction","RestoreFromTrashRepository","RestoreFromTrashUseCase"],"mappings":";AAYO,MAAMA,0BACTC,kBAA4C;AAUzC,MAAMC,6BAA6BD,kBACtC;AAWG,MAAME,0BACTF,kBAA4C"}

package/features/contentEntry/restoreFromTrash/feature.d.ts

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

package/features/contentEntry/restoreFromTrash/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { RestoreFromTrashUseCase } from "./abstractions.js";
+import { RestoreFromTrashUseCase as external_RestoreFromTrashUseCase_js_RestoreFromTrashUseCase } from "./RestoreFromTrashUseCase.js";
+import { RestoreFromTrashRepository } from "./RestoreFromTrashRepository.js";
+import { RestoreFromTrashGateway } from "./RestoreFromTrashGateway.js";
+const RestoreFromTrashFeature = createFeature({
+    name: "CmsContentEntry/RestoreFromTrash",
+    register (container) {
+        container.register(external_RestoreFromTrashUseCase_js_RestoreFromTrashUseCase);
+        container.register(RestoreFromTrashRepository).inSingletonScope();
+        container.register(RestoreFromTrashGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(RestoreFromTrashUseCase)
+        };
+    }
+});
+export { RestoreFromTrashFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/restoreFromTrash/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/restoreFromTrash/feature.js","sources":["../../../../src/features/contentEntry/restoreFromTrash/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { RestoreFromTrashUseCase as UseCase } from \"./abstractions.js\";\nimport { RestoreFromTrashUseCase } from \"./RestoreFromTrashUseCase.js\";\nimport { RestoreFromTrashRepository } from \"./RestoreFromTrashRepository.js\";\nimport { RestoreFromTrashGateway } from \"./RestoreFromTrashGateway.js\";\n\nexport const RestoreFromTrashFeature = createFeature({\n    name: \"CmsContentEntry/RestoreFromTrash\",\n    register(container) {\n        container.register(RestoreFromTrashUseCase);\n        container.register(RestoreFromTrashRepository).inSingletonScope();\n        container.register(RestoreFromTrashGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["RestoreFromTrashFeature","createFeature","container","RestoreFromTrashUseCase","RestoreFromTrashRepository","RestoreFromTrashGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,4BAA4B,gBAAgB;QAC/DF,UAAU,QAAQ,CAACG,yBAAyB,gBAAgB;IAChE;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/contentEntry/searchContentEntries/SearchContentEntriesGateway.d.ts

@@ -0,0 +1,11 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import { SearchContentEntriesGateway as GatewayAbstraction, type ISearchContentEntriesGatewayParams, type ISearchContentEntriesGatewayResult } from "./abstractions.js";
+declare class SearchContentEntriesGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(params: ISearchContentEntriesGatewayParams): Promise<ISearchContentEntriesGatewayResult>;
+}
+export declare const SearchContentEntriesGateway: typeof SearchContentEntriesGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ISearchContentEntriesGateway>;
+};
+export {};

package/features/contentEntry/searchContentEntries/SearchContentEntriesGateway.js

@@ -0,0 +1,39 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { REFERENCE_ENTRY_FIELDS } from "../refTypes.js";
+import { SearchContentEntriesGateway } from "./abstractions.js";
+const SEARCH_CONTENT_ENTRIES = `
+    query CmsSearchContentEntries($modelIds: [ID!]!, $query: String, $limit: Int) {
+        content: searchContentEntries(modelIds: $modelIds, query: $query, limit: $limit) {
+            ${REFERENCE_ENTRY_FIELDS}
+        }
+    }
+`;
+class SearchContentEntriesGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: SEARCH_CONTENT_ENTRIES,
+            variables: {
+                modelIds: params.modelIds,
+                query: params.query,
+                limit: params.limit
+            }
+        });
+        const { data, error } = response.content;
+        if (!data) throw new Error(error?.message || "Could not search content entries");
+        return {
+            data
+        };
+    }
+}
+const SearchContentEntriesGateway_SearchContentEntriesGateway = SearchContentEntriesGateway.createImplementation({
+    implementation: SearchContentEntriesGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { SearchContentEntriesGateway_SearchContentEntriesGateway as SearchContentEntriesGateway };
+
+//# sourceMappingURL=SearchContentEntriesGateway.js.map

package/features/contentEntry/searchContentEntries/SearchContentEntriesGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/searchContentEntries/SearchContentEntriesGateway.js","sources":["../../../../src/features/contentEntry/searchContentEntries/SearchContentEntriesGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsErrorResponse } from \"~/types.js\";\nimport type { CmsReferenceEntry } from \"../refTypes.js\";\nimport { REFERENCE_ENTRY_FIELDS } from \"../refTypes.js\";\nimport {\n    SearchContentEntriesGateway as GatewayAbstraction,\n    type ISearchContentEntriesGatewayParams,\n    type ISearchContentEntriesGatewayResult\n} from \"./abstractions.js\";\n\ninterface SearchContentEntriesResponse {\n    content: {\n        data: CmsReferenceEntry[] | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nconst SEARCH_CONTENT_ENTRIES = /* GraphQL */ `\n    query CmsSearchContentEntries($modelIds: [ID!]!, $query: String, $limit: Int) {\n        content: searchContentEntries(modelIds: $modelIds, query: $query, limit: $limit) {\n            ${REFERENCE_ENTRY_FIELDS}\n        }\n    }\n`;\n\nclass SearchContentEntriesGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute(\n        params: ISearchContentEntriesGatewayParams\n    ): Promise<ISearchContentEntriesGatewayResult> {\n        const response = await this.client.execute<SearchContentEntriesResponse>({\n            query: SEARCH_CONTENT_ENTRIES,\n            variables: {\n                modelIds: params.modelIds,\n                query: params.query,\n                limit: params.limit\n            }\n        });\n\n        const { data, error } = response.content;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not search content entries\");\n        }\n\n        return { data };\n    }\n}\n\nexport const SearchContentEntriesGateway = GatewayAbstraction.createImplementation({\n    implementation: SearchContentEntriesGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["SEARCH_CONTENT_ENTRIES","REFERENCE_ENTRY_FIELDS","SearchContentEntriesGatewayImpl","client","params","response","data","error","Error","SearchContentEntriesGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;;AAiBA,MAAMA,yBAAuC,CAAC;;;YAGlC,EAAEC,uBAAuB;;;AAGrC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QACFC,MAA0C,EACC;QAC3C,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA+B;YACrE,OAAOL;YACP,WAAW;gBACP,UAAUI,OAAO,QAAQ;gBACzB,OAAOA,OAAO,KAAK;gBACnB,OAAOA,OAAO,KAAK;YACvB;QACJ;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAExC,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAO;YAAED;QAAK;IAClB;AACJ;AAEO,MAAMG,0DAA8BC,4BAAAA,oBAAuC,CAAC;IAC/E,gBAAgBR;IAChB,cAAc;QAACS;KAAiB;AACpC"}

package/features/contentEntry/searchContentEntries/SearchContentEntriesUseCase.d.ts

@@ -0,0 +1,11 @@
+import { SearchContentEntriesUseCase as UseCaseAbstraction, SearchContentEntriesGateway } from "./abstractions.js";
+import type { ISearchContentEntriesUseCaseParams } from "./abstractions.js";
+declare class SearchContentEntriesUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: SearchContentEntriesGateway.Interface);
+    execute(params: ISearchContentEntriesUseCaseParams): Promise<import("./abstractions.js").ISearchContentEntriesGatewayResult>;
+}
+export declare const SearchContentEntriesUseCase: typeof SearchContentEntriesUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ISearchContentEntriesUseCase>;
+};
+export {};

package/features/contentEntry/searchContentEntries/SearchContentEntriesUseCase.js

@@ -0,0 +1,18 @@
+import { SearchContentEntriesGateway, SearchContentEntriesUseCase } from "./abstractions.js";
+class SearchContentEntriesUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const SearchContentEntriesUseCase_SearchContentEntriesUseCase = SearchContentEntriesUseCase.createImplementation({
+    implementation: SearchContentEntriesUseCaseImpl,
+    dependencies: [
+        SearchContentEntriesGateway
+    ]
+});
+export { SearchContentEntriesUseCase_SearchContentEntriesUseCase as SearchContentEntriesUseCase };
+
+//# sourceMappingURL=SearchContentEntriesUseCase.js.map

package/features/contentEntry/searchContentEntries/SearchContentEntriesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/searchContentEntries/SearchContentEntriesUseCase.js","sources":["../../../../src/features/contentEntry/searchContentEntries/SearchContentEntriesUseCase.ts"],"sourcesContent":["import {\n    SearchContentEntriesUseCase as UseCaseAbstraction,\n    SearchContentEntriesGateway\n} from \"./abstractions.js\";\nimport type { ISearchContentEntriesUseCaseParams } from \"./abstractions.js\";\n\nclass SearchContentEntriesUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: SearchContentEntriesGateway.Interface) {}\n\n    async execute(params: ISearchContentEntriesUseCaseParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const SearchContentEntriesUseCase = UseCaseAbstraction.createImplementation({\n    implementation: SearchContentEntriesUseCaseImpl,\n    dependencies: [SearchContentEntriesGateway]\n});\n"],"names":["SearchContentEntriesUseCaseImpl","gateway","params","SearchContentEntriesUseCase","UseCaseAbstraction","SearchContentEntriesGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAA8C,CAAE;aAAhDA,OAAO,GAAPA;IAAiD;IAErE,MAAM,QAAQC,MAA0C,EAAE;QACtD,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,0DAA8BC,4BAAAA,oBAAuC,CAAC;IAC/E,gBAAgBJ;IAChB,cAAc;QAACK;KAA4B;AAC/C"}

package/features/contentEntry/searchContentEntries/abstractions.d.ts

@@ -0,0 +1,31 @@
+import type { CmsReferenceEntry } from "../refTypes.js";
+export interface ISearchContentEntriesGatewayParams {
+    modelIds: string[];
+    query?: string;
+    limit?: number;
+}
+export interface ISearchContentEntriesGatewayResult {
+    data: CmsReferenceEntry[];
+}
+export interface ISearchContentEntriesGateway {
+    execute(params: ISearchContentEntriesGatewayParams): Promise<ISearchContentEntriesGatewayResult>;
+}
+export declare const SearchContentEntriesGateway: import("@webiny/di").Abstraction<ISearchContentEntriesGateway>;
+export declare namespace SearchContentEntriesGateway {
+    type Interface = ISearchContentEntriesGateway;
+}
+export interface ISearchContentEntriesUseCaseParams {
+    modelIds: string[];
+    query?: string;
+    limit?: number;
+}
+export interface ISearchContentEntriesUseCaseResult {
+    data: CmsReferenceEntry[];
+}
+export interface ISearchContentEntriesUseCase {
+    execute(params: ISearchContentEntriesUseCaseParams): Promise<ISearchContentEntriesUseCaseResult>;
+}
+export declare const SearchContentEntriesUseCase: import("@webiny/di").Abstraction<ISearchContentEntriesUseCase>;
+export declare namespace SearchContentEntriesUseCase {
+    type Interface = ISearchContentEntriesUseCase;
+}

package/features/contentEntry/searchContentEntries/abstractions.js

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

package/features/contentEntry/searchContentEntries/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/searchContentEntries/abstractions.js","sources":["../../../../src/features/contentEntry/searchContentEntries/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsReferenceEntry } from \"../refTypes.js\";\n\n// Gateway\n\nexport interface ISearchContentEntriesGatewayParams {\n    modelIds: string[];\n    query?: string;\n    limit?: number;\n}\n\nexport interface ISearchContentEntriesGatewayResult {\n    data: CmsReferenceEntry[];\n}\n\nexport interface ISearchContentEntriesGateway {\n    execute(\n        params: ISearchContentEntriesGatewayParams\n    ): Promise<ISearchContentEntriesGatewayResult>;\n}\n\nexport const SearchContentEntriesGateway = createAbstraction<ISearchContentEntriesGateway>(\n    \"SearchContentEntriesGateway\"\n);\n\nexport namespace SearchContentEntriesGateway {\n    export type Interface = ISearchContentEntriesGateway;\n}\n\n// UseCase\n\nexport interface ISearchContentEntriesUseCaseParams {\n    modelIds: string[];\n    query?: string;\n    limit?: number;\n}\n\nexport interface ISearchContentEntriesUseCaseResult {\n    data: CmsReferenceEntry[];\n}\n\nexport interface ISearchContentEntriesUseCase {\n    execute(\n        params: ISearchContentEntriesUseCaseParams\n    ): Promise<ISearchContentEntriesUseCaseResult>;\n}\n\nexport const SearchContentEntriesUseCase = createAbstraction<ISearchContentEntriesUseCase>(\n    \"SearchContentEntriesUseCase\"\n);\n\nexport namespace SearchContentEntriesUseCase {\n    export type Interface = ISearchContentEntriesUseCase;\n}\n"],"names":["SearchContentEntriesGateway","createAbstraction","SearchContentEntriesUseCase"],"mappings":";AAqBO,MAAMA,8BAA8BC,kBACvC;AAyBG,MAAMC,8BAA8BD,kBACvC"}

package/features/contentEntry/searchContentEntries/feature.d.ts

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

package/features/contentEntry/searchContentEntries/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { SearchContentEntriesUseCase } from "./abstractions.js";
+import { SearchContentEntriesUseCase as external_SearchContentEntriesUseCase_js_SearchContentEntriesUseCase } from "./SearchContentEntriesUseCase.js";
+import { SearchContentEntriesGateway } from "./SearchContentEntriesGateway.js";
+const SearchContentEntriesFeature = createFeature({
+    name: "CmsContentEntry/SearchContentEntries",
+    register (container) {
+        container.register(external_SearchContentEntriesUseCase_js_SearchContentEntriesUseCase);
+        container.register(SearchContentEntriesGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(SearchContentEntriesUseCase)
+        };
+    }
+});
+export { SearchContentEntriesFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/searchContentEntries/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/searchContentEntries/feature.js","sources":["../../../../src/features/contentEntry/searchContentEntries/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { SearchContentEntriesUseCase as UseCase } from \"./abstractions.js\";\nimport { SearchContentEntriesUseCase } from \"./SearchContentEntriesUseCase.js\";\nimport { SearchContentEntriesGateway } from \"./SearchContentEntriesGateway.js\";\n\nexport const SearchContentEntriesFeature = createFeature({\n    name: \"CmsContentEntry/SearchContentEntries\",\n    register(container) {\n        container.register(SearchContentEntriesUseCase);\n        container.register(SearchContentEntriesGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["SearchContentEntriesFeature","createFeature","container","SearchContentEntriesUseCase","SearchContentEntriesGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,6BAA6B,gBAAgB;IACpE;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/features/contentEntry/singletonEntry/GetSingletonEntryGateway.d.ts

@@ -0,0 +1,14 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { GetSingletonEntryGateway as GatewayAbstraction, type IGetSingletonEntryParams } from "./abstractions.js";
+declare class GetSingletonEntryGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private fields;
+    constructor(client: CmsGraphQLClient.Interface, fields: EntryGraphQLFields.Interface);
+    execute({ model }: IGetSingletonEntryParams): Promise<CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const GetSingletonEntryGateway: typeof GetSingletonEntryGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetSingletonEntryGateway>;
+};
+export {};

package/features/contentEntry/singletonEntry/GetSingletonEntryGateway.js

@@ -0,0 +1,40 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { GetSingletonEntryGateway } from "./abstractions.js";
+function createQuery(model, fields) {
+    return `
+        query CmsEntryGetSingleton${model.singularApiName} {
+            content: get${model.singularApiName} {
+                data {
+                    ${fields.getSystemFields(model)}
+                    ${fields.getValuesBlock(model)}
+                }
+                error { message code data }
+            }
+        }
+    `;
+}
+class GetSingletonEntryGatewayImpl {
+    constructor(client, fields){
+        this.client = client;
+        this.fields = fields;
+    }
+    async execute({ model }) {
+        const response = await this.client.execute({
+            query: createQuery(model, this.fields)
+        });
+        const { data, error } = response.content;
+        if (!data) throw new Error(error?.message || "Could not fetch singleton entry");
+        return data;
+    }
+}
+const GetSingletonEntryGateway_GetSingletonEntryGateway = GetSingletonEntryGateway.createImplementation({
+    implementation: GetSingletonEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient,
+        EntryGraphQLFields
+    ]
+});
+export { GetSingletonEntryGateway_GetSingletonEntryGateway as GetSingletonEntryGateway };
+
+//# sourceMappingURL=GetSingletonEntryGateway.js.map

package/features/contentEntry/singletonEntry/GetSingletonEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/singletonEntry/GetSingletonEntryGateway.js","sources":["../../../../src/features/contentEntry/singletonEntry/GetSingletonEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    GetSingletonEntryGateway as GatewayAbstraction,\n    type IGetSingletonEntryParams\n} from \"./abstractions.js\";\n\ninterface GetSingletonEntryResponse {\n    content: {\n        data: CmsContentEntry | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nfunction createQuery(model: CmsModel, fields: EntryGraphQLFields.Interface) {\n    return /* GraphQL */ `\n        query CmsEntryGetSingleton${model.singularApiName} {\n            content: get${model.singularApiName} {\n                data {\n                    ${fields.getSystemFields(model)}\n                    ${fields.getValuesBlock(model)}\n                }\n                error { message code data }\n            }\n        }\n    `;\n}\n\nclass GetSingletonEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model }: IGetSingletonEntryParams) {\n        const response = await this.client.execute<GetSingletonEntryResponse>({\n            query: createQuery(model, this.fields)\n        });\n\n        const { data, error } = response.content;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not fetch singleton entry\");\n        }\n\n        return data;\n    }\n}\n\nexport const GetSingletonEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: GetSingletonEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryGraphQLFields]\n});\n"],"names":["createQuery","model","fields","GetSingletonEntryGatewayImpl","client","response","data","error","Error","GetSingletonEntryGateway","GatewayAbstraction","CmsGraphQLClient","EntryGraphQLFields"],"mappings":";;;AAeA,SAASA,YAAYC,KAAe,EAAEC,MAAoC;IACtE,OAAqB,CAAC;kCACQ,EAAED,MAAM,eAAe,CAAC;wBAClC,EAAEA,MAAM,eAAe,CAAC;;oBAE5B,EAAEC,OAAO,eAAe,CAACD,OAAO;oBAChC,EAAEC,OAAO,cAAc,CAACD,OAAO;;;;;IAK/C,CAAC;AACL;AAEA,MAAME;IACF,YACYC,MAAkC,EAClCF,MAAoC,CAC9C;aAFUE,MAAM,GAANA;aACAF,MAAM,GAANA;IACT;IAEH,MAAM,QAAQ,EAAED,KAAK,EAA4B,EAAE;QAC/C,MAAMI,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA4B;YAClE,OAAOL,YAAYC,OAAO,IAAI,CAAC,MAAM;QACzC;QAEA,MAAM,EAAEK,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAExC,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,oDAA2BC,yBAAAA,oBAAuC,CAAC;IAC5E,gBAAgBP;IAChB,cAAc;QAACQ;QAAkBC;KAAmB;AACxD"}

package/features/contentEntry/singletonEntry/GetSingletonEntryUseCase.d.ts

@@ -0,0 +1,11 @@
+import { GetSingletonEntryUseCase as UseCaseAbstraction, GetSingletonEntryGateway } from "./abstractions.js";
+import type { IGetSingletonEntryParams } from "./abstractions.js";
+declare class GetSingletonEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: GetSingletonEntryGateway.Interface);
+    execute(params: IGetSingletonEntryParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const GetSingletonEntryUseCase: typeof GetSingletonEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetSingletonEntryUseCase>;
+};
+export {};

package/features/contentEntry/singletonEntry/GetSingletonEntryUseCase.js

@@ -0,0 +1,18 @@
+import { GetSingletonEntryGateway, GetSingletonEntryUseCase } from "./abstractions.js";
+class GetSingletonEntryUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const GetSingletonEntryUseCase_GetSingletonEntryUseCase = GetSingletonEntryUseCase.createImplementation({
+    implementation: GetSingletonEntryUseCaseImpl,
+    dependencies: [
+        GetSingletonEntryGateway
+    ]
+});
+export { GetSingletonEntryUseCase_GetSingletonEntryUseCase as GetSingletonEntryUseCase };
+
+//# sourceMappingURL=GetSingletonEntryUseCase.js.map

package/features/contentEntry/singletonEntry/GetSingletonEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/singletonEntry/GetSingletonEntryUseCase.js","sources":["../../../../src/features/contentEntry/singletonEntry/GetSingletonEntryUseCase.ts"],"sourcesContent":["import {\n    GetSingletonEntryUseCase as UseCaseAbstraction,\n    GetSingletonEntryGateway\n} from \"./abstractions.js\";\nimport type { IGetSingletonEntryParams } from \"./abstractions.js\";\n\nclass GetSingletonEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: GetSingletonEntryGateway.Interface) {}\n\n    async execute(params: IGetSingletonEntryParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const GetSingletonEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetSingletonEntryUseCaseImpl,\n    dependencies: [GetSingletonEntryGateway]\n});\n"],"names":["GetSingletonEntryUseCaseImpl","gateway","params","GetSingletonEntryUseCase","UseCaseAbstraction","GetSingletonEntryGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAA2C,CAAE;aAA7CA,OAAO,GAAPA;IAA8C;IAElE,MAAM,QAAQC,MAAgC,EAAE;QAC5C,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,oDAA2BC,yBAAAA,oBAAuC,CAAC;IAC5E,gBAAgBJ;IAChB,cAAc;QAACK;KAAyB;AAC5C"}

package/features/contentEntry/singletonEntry/UpdateSingletonEntryGateway.d.ts

@@ -0,0 +1,16 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { UpdateSingletonEntryGateway as GatewayAbstraction, type IUpdateSingletonEntryParams } from "./abstractions.js";
+import { EntryDataPreparer } from "../../../features/contentEntry/valueTransformers/EntryDataPreparer.js";
+declare class UpdateSingletonEntryGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private preparer;
+    private fields;
+    constructor(client: CmsGraphQLClient.Interface, preparer: EntryDataPreparer.Interface, fields: EntryGraphQLFields.Interface);
+    execute({ model, data, options }: IUpdateSingletonEntryParams): Promise<CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const UpdateSingletonEntryGateway: typeof UpdateSingletonEntryGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateSingletonEntryGateway>;
+};
+export {};