@webiny/api-headless-cms 6.0.0-beta.0 → 6.0.0-rc.1

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

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * GetRevisionsByEntryId Use Case - Fetches all revisions for a given entry ID.
+ * Returns array of entry revisions.
+ */
+export interface IGetRevisionsByEntryIdUseCase {
+    execute<T extends CmsEntryValues>(model: CmsModel, entryId: string): Promise<Result<CmsEntry<T>[], UseCaseError>>;
+}
+export interface IGetRevisionsByEntryIdUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IGetRevisionsByEntryIdUseCaseErrors[keyof IGetRevisionsByEntryIdUseCaseErrors];
+export declare const GetRevisionsByEntryIdUseCase: import("@webiny/di").Abstraction<IGetRevisionsByEntryIdUseCase>;
+export declare namespace GetRevisionsByEntryIdUseCase {
+    type Interface = IGetRevisionsByEntryIdUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>[], UseCaseError>>;
+}
+/**
+ * GetRevisionsByEntryIdRepository - Fetches entry revisions from storage.
+ */
+export interface IGetRevisionsByEntryIdRepository {
+    execute<T extends CmsEntryValues>(model: CmsModel, entryId: string): Promise<Result<CmsEntry<T>[], RepositoryError>>;
+}
+export interface IGetRevisionsByEntryIdRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IGetRevisionsByEntryIdRepositoryErrors[keyof IGetRevisionsByEntryIdRepositoryErrors];
+export declare const GetRevisionsByEntryIdRepository: import("@webiny/di").Abstraction<IGetRevisionsByEntryIdRepository>;
+export declare namespace GetRevisionsByEntryIdRepository {
+    type Interface = IGetRevisionsByEntryIdRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/GetRevisionsByEntryId/abstractions.js

@@ -0,0 +1,16 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetRevisionsByEntryId Use Case - Fetches all revisions for a given entry ID.
+ * Returns array of entry revisions.
+ */
+
+export const GetRevisionsByEntryIdUseCase = createAbstraction("GetRevisionsByEntryIdUseCase");
+
+/**
+ * GetRevisionsByEntryIdRepository - Fetches entry revisions from storage.
+ */
+
+export const GetRevisionsByEntryIdRepository = createAbstraction("GetRevisionsByEntryIdRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetRevisionsByEntryIdUseCase","GetRevisionsByEntryIdRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport type {\n    EntryNotAuthorizedError,\n    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * GetRevisionsByEntryId Use Case - Fetches all revisions for a given entry ID.\n * Returns array of entry revisions.\n */\nexport interface IGetRevisionsByEntryIdUseCase {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        entryId: string\n    ): Promise<Result<CmsEntry<T>[], UseCaseError>>;\n}\n\nexport interface IGetRevisionsByEntryIdUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IGetRevisionsByEntryIdUseCaseErrors[keyof IGetRevisionsByEntryIdUseCaseErrors];\n\nexport const GetRevisionsByEntryIdUseCase = createAbstraction<IGetRevisionsByEntryIdUseCase>(\n    \"GetRevisionsByEntryIdUseCase\"\n);\n\nexport namespace GetRevisionsByEntryIdUseCase {\n    export type Interface = IGetRevisionsByEntryIdUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>[], UseCaseError>>;\n}\n\n/**\n * GetRevisionsByEntryIdRepository - Fetches entry revisions from storage.\n */\nexport interface IGetRevisionsByEntryIdRepository {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        entryId: string\n    ): Promise<Result<CmsEntry<T>[], RepositoryError>>;\n}\n\nexport interface IGetRevisionsByEntryIdRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError =\n    IGetRevisionsByEntryIdRepositoryErrors[keyof IGetRevisionsByEntryIdRepositoryErrors];\n\nexport const GetRevisionsByEntryIdRepository = createAbstraction<IGetRevisionsByEntryIdRepository>(\n    \"GetRevisionsByEntryIdRepository\"\n);\n\nexport namespace GetRevisionsByEntryIdRepository {\n    export type Interface = IGetRevisionsByEntryIdRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAO/D;AACA;AACA;AACA;;AAeA,OAAO,MAAMC,4BAA4B,GAAGD,iBAAiB,CACzD,8BACJ,CAAC;;AAQD;AACA;AACA;;AAeA,OAAO,MAAME,+BAA+B,GAAGF,iBAAiB,CAC5D,iCACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const GetRevisionsByEntryIdFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentEntry/GetRevisionsByEntryId/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetRevisionsByEntryIdUseCase } from "./GetRevisionsByEntryIdUseCase.js";
+import { GetRevisionsByEntryIdRepository } from "./GetRevisionsByEntryIdRepository.js";
+export const GetRevisionsByEntryIdFeature = createFeature({
+  name: "GetRevisionsByEntryId",
+  register(container) {
+    container.register(GetRevisionsByEntryIdUseCase);
+    container.register(GetRevisionsByEntryIdRepository).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetRevisionsByEntryIdUseCase","GetRevisionsByEntryIdRepository","GetRevisionsByEntryIdFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetRevisionsByEntryIdUseCase } from \"./GetRevisionsByEntryIdUseCase.js\";\nimport { GetRevisionsByEntryIdRepository } from \"./GetRevisionsByEntryIdRepository.js\";\n\nexport const GetRevisionsByEntryIdFeature = createFeature({\n    name: \"GetRevisionsByEntryId\",\n    register(container) {\n        container.register(GetRevisionsByEntryIdUseCase);\n        container.register(GetRevisionsByEntryIdRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,4BAA4B;AACrC,SAASC,+BAA+B;AAExC,OAAO,MAAMC,4BAA4B,GAAGH,aAAa,CAAC;EACtDI,IAAI,EAAE,uBAAuB;EAC7BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,4BAA4B,CAAC;IAChDK,SAAS,CAACD,QAAQ,CAACH,+BAA+B,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAC1E;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetRevisionsByEntryId/index.d.ts

@@ -0,0 +1 @@
+export { GetRevisionsByEntryIdUseCase, GetRevisionsByEntryIdRepository } from "./abstractions.js";

package/features/contentEntry/GetRevisionsByEntryId/index.js

@@ -0,0 +1,3 @@
+export { GetRevisionsByEntryIdUseCase, GetRevisionsByEntryIdRepository } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/contentEntry/GetRevisionsByEntryId/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetRevisionsByEntryIdUseCase","GetRevisionsByEntryIdRepository"],"sources":["index.ts"],"sourcesContent":["export { GetRevisionsByEntryIdUseCase, GetRevisionsByEntryIdRepository } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,4BAA4B,EAAEC,+BAA+B","ignoreList":[]}

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

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { GetSingletonEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import { CreateEntryUseCase } from "../../../features/contentEntry/CreateEntry/index.js";
+import { GetEntryByIdUseCase } from "../../../features/contentEntry/GetEntryById/index.js";
+/**
+ * GetSingletonEntryUseCase - Gets the singleton entry for a model.
+ *
+ * Responsibilities:
+ * - Validate model is marked as singleton
+ * - Generate singleton entry ID from model ID
+ * - Try to get existing entry
+ * - If not found, create a new entry with skipValidators: ["required"]
+ * - Delegate to generic GetEntry and CreateEntry use cases
+ */
+declare class GetSingletonEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getEntryById;
+    private createEntry;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, createEntry: CreateEntryUseCase.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+}
+export declare const GetSingletonEntryUseCase: typeof GetSingletonEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetSingletonEntryUseCase>;
+};
+export {};

package/features/contentEntry/GetSingletonEntry/GetSingletonEntryUseCase.js

@@ -0,0 +1,56 @@
+import { Result } from "@webiny/feature/api";
+import { GetSingletonEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CMS_MODEL_SINGLETON_TAG } from "../../../constants.js";
+import { EntryValidationError } from "../../../domain/contentEntry/errors.js";
+import { createCacheKey } from "@webiny/utils";
+import { CreateEntryUseCase } from "../CreateEntry/index.js";
+import { GetEntryByIdUseCase } from "../GetEntryById/index.js";
+
+/**
+ * GetSingletonEntryUseCase - Gets the singleton entry for a model.
+ *
+ * Responsibilities:
+ * - Validate model is marked as singleton
+ * - Generate singleton entry ID from model ID
+ * - Try to get existing entry
+ * - If not found, create a new entry with skipValidators: ["required"]
+ * - Delegate to generic GetEntry and CreateEntry use cases
+ */
+class GetSingletonEntryUseCaseImpl {
+  constructor(getEntryById, createEntry) {
+    this.getEntryById = getEntryById;
+    this.createEntry = createEntry;
+  }
+  async execute(model) {
+    // Validate model is marked as singleton
+    if (!model.tags?.includes(CMS_MODEL_SINGLETON_TAG)) {
+      return Result.fail(new EntryValidationError("Model is not marked as singleton."));
+    }
+
+    // Generate singleton entry ID from model ID
+    const id = createCacheKey(model.modelId);
+    const entryId = `${id}#0001`;
+
+    // Try to get existing entry
+    const getResult = await this.getEntryById.execute(model, entryId);
+    if (getResult.isOk()) {
+      return getResult;
+    }
+
+    // Entry doesn't exist, create it
+    return await this.createEntry.execute(model, {
+      id,
+      values: {
+        // safe to cast
+      }
+    }, {
+      skipValidators: ["required"]
+    });
+  }
+}
+export const GetSingletonEntryUseCase = UseCaseAbstraction.createImplementation({
+  implementation: GetSingletonEntryUseCaseImpl,
+  dependencies: [GetEntryByIdUseCase, CreateEntryUseCase]
+});
+
+//# sourceMappingURL=GetSingletonEntryUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetSingletonEntryUseCase","UseCaseAbstraction","CMS_MODEL_SINGLETON_TAG","EntryValidationError","createCacheKey","CreateEntryUseCase","GetEntryByIdUseCase","GetSingletonEntryUseCaseImpl","constructor","getEntryById","createEntry","execute","model","tags","includes","fail","id","modelId","entryId","getResult","isOk","values","skipValidators","createImplementation","implementation","dependencies"],"sources":["GetSingletonEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetSingletonEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { CMS_MODEL_SINGLETON_TAG } from \"~/constants.js\";\nimport { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport { createCacheKey } from \"@webiny/utils\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { CreateEntryUseCase } from \"~/features/contentEntry/CreateEntry/index.js\";\nimport { GetEntryByIdUseCase } from \"~/features/contentEntry/GetEntryById/index.js\";\n\n/**\n * GetSingletonEntryUseCase - Gets the singleton entry for a model.\n *\n * Responsibilities:\n * - Validate model is marked as singleton\n * - Generate singleton entry ID from model ID\n * - Try to get existing entry\n * - If not found, create a new entry with skipValidators: [\"required\"]\n * - Delegate to generic GetEntry and CreateEntry use cases\n */\nclass GetSingletonEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private createEntry: CreateEntryUseCase.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel\n    ): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>> {\n        // Validate model is marked as singleton\n        if (!model.tags?.includes(CMS_MODEL_SINGLETON_TAG)) {\n            return Result.fail(new EntryValidationError(\"Model is not marked as singleton.\"));\n        }\n\n        // Generate singleton entry ID from model ID\n        const id = createCacheKey(model.modelId);\n        const entryId = `${id}#0001`;\n\n        // Try to get existing entry\n        const getResult = await this.getEntryById.execute<T>(model, entryId);\n\n        if (getResult.isOk()) {\n            return getResult;\n        }\n\n        // Entry doesn't exist, create it\n        return await this.createEntry.execute<T>(\n            model,\n            {\n                id,\n                values: {\n                    // safe to cast\n                } as T\n            },\n            { skipValidators: [\"required\"] }\n        );\n    }\n}\n\nexport const GetSingletonEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetSingletonEntryUseCaseImpl,\n    dependencies: [GetEntryByIdUseCase, CreateEntryUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,wBAAwB,IAAIC,kBAAkB;AACvD,SAASC,uBAAuB;AAChC,SAASC,oBAAoB;AAC7B,SAASC,cAAc,QAAQ,eAAe;AAE9C,SAASC,kBAAkB;AAC3B,SAASC,mBAAmB;;AAE5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,4BAA4B,CAAyC;EAChEC,WAAWA,CACNC,YAA2C,EAC3CC,WAAyC,EACnD;IAAA,KAFUD,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,WAAyC,GAAzCA,WAAyC;EAClD;EAEH,MAAMC,OAAOA,CACTC,KAAe,EACuC;IACtD;IACA,IAAI,CAACA,KAAK,CAACC,IAAI,EAAEC,QAAQ,CAACZ,uBAAuB,CAAC,EAAE;MAChD,OAAOH,MAAM,CAACgB,IAAI,CAAC,IAAIZ,oBAAoB,CAAC,mCAAmC,CAAC,CAAC;IACrF;;IAEA;IACA,MAAMa,EAAE,GAAGZ,cAAc,CAACQ,KAAK,CAACK,OAAO,CAAC;IACxC,MAAMC,OAAO,GAAG,GAAGF,EAAE,OAAO;;IAE5B;IACA,MAAMG,SAAS,GAAG,MAAM,IAAI,CAACV,YAAY,CAACE,OAAO,CAAIC,KAAK,EAAEM,OAAO,CAAC;IAEpE,IAAIC,SAAS,CAACC,IAAI,CAAC,CAAC,EAAE;MAClB,OAAOD,SAAS;IACpB;;IAEA;IACA,OAAO,MAAM,IAAI,CAACT,WAAW,CAACC,OAAO,CACjCC,KAAK,EACL;MACII,EAAE;MACFK,MAAM,EAAE;QACJ;MAAA;IAER,CAAC,EACD;MAAEC,cAAc,EAAE,CAAC,UAAU;IAAE,CACnC,CAAC;EACL;AACJ;AAEA,OAAO,MAAMtB,wBAAwB,GAAGC,kBAAkB,CAACsB,oBAAoB,CAAC;EAC5EC,cAAc,EAAEjB,4BAA4B;EAC5CkB,YAAY,EAAE,CAACnB,mBAAmB,EAAED,kBAAkB;AAC1D,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import { type EntryNotAuthorizedError, type EntryNotFoundError, type EntryPersistenceError, type EntryValidationError } from "../../../domain/contentEntry/errors.js";
+/**
+ * GetSingletonEntry Use Case
+ *
+ * Gets the singleton entry for a model, creating it if it doesn't exist.
+ */
+export interface IGetSingletonEntryUseCase {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel): Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+export interface IGetSingletonEntryUseCaseErrors {
+    notFound: EntryNotFoundError;
+    notAuthorized: EntryNotAuthorizedError;
+    validation: EntryValidationError;
+    persistence: EntryPersistenceError;
+}
+type UseCaseError = IGetSingletonEntryUseCaseErrors[keyof IGetSingletonEntryUseCaseErrors];
+export declare const GetSingletonEntryUseCase: import("@webiny/di").Abstraction<IGetSingletonEntryUseCase>;
+export declare namespace GetSingletonEntryUseCase {
+    type Interface = IGetSingletonEntryUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+export {};

package/features/contentEntry/GetSingletonEntry/abstractions.js

@@ -0,0 +1,11 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetSingletonEntry Use Case
+ *
+ * Gets the singleton entry for a model, creating it if it doesn't exist.
+ */
+
+export const GetSingletonEntryUseCase = createAbstraction("GetSingletonEntryUseCase");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetSingletonEntryUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport {\n    type EntryNotAuthorizedError,\n    type EntryNotFoundError,\n    type EntryPersistenceError,\n    type EntryValidationError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * GetSingletonEntry Use Case\n *\n * Gets the singleton entry for a model, creating it if it doesn't exist.\n */\nexport interface IGetSingletonEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IGetSingletonEntryUseCaseErrors {\n    notFound: EntryNotFoundError;\n    notAuthorized: EntryNotAuthorizedError;\n    validation: EntryValidationError;\n    persistence: EntryPersistenceError;\n}\n\ntype UseCaseError = IGetSingletonEntryUseCaseErrors[keyof IGetSingletonEntryUseCaseErrors];\n\nexport const GetSingletonEntryUseCase = createAbstraction<IGetSingletonEntryUseCase>(\n    \"GetSingletonEntryUseCase\"\n);\n\nexport namespace GetSingletonEntryUseCase {\n    export type Interface = IGetSingletonEntryUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<\n        Result<CmsEntry<T>, UseCaseError>\n    >;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAS/D;AACA;AACA;AACA;AACA;;AAgBA,OAAO,MAAMC,wBAAwB,GAAGD,iBAAiB,CACrD,0BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,7 @@
+/**
+ * GetSingletonEntry Feature
+ *
+ * Provides functionality for getting singleton entries.
+ * Creates the entry if it doesn't exist.
+ */
+export declare const GetSingletonEntryFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentEntry/GetSingletonEntry/feature.js

@@ -0,0 +1,18 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetSingletonEntryUseCase } from "./GetSingletonEntryUseCase.js";
+
+/**
+ * GetSingletonEntry Feature
+ *
+ * Provides functionality for getting singleton entries.
+ * Creates the entry if it doesn't exist.
+ */
+export const GetSingletonEntryFeature = createFeature({
+  name: "GetSingletonEntry",
+  register(container) {
+    // Register use case
+    container.register(GetSingletonEntryUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetSingletonEntryUseCase","GetSingletonEntryFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetSingletonEntryUseCase } from \"./GetSingletonEntryUseCase.js\";\n\n/**\n * GetSingletonEntry Feature\n *\n * Provides functionality for getting singleton entries.\n * Creates the entry if it doesn't exist.\n */\nexport const GetSingletonEntryFeature = createFeature({\n    name: \"GetSingletonEntry\",\n    register(container) {\n        // Register use case\n        container.register(GetSingletonEntryUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,wBAAwB;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,wBAAwB,GAAGF,aAAa,CAAC;EAClDG,IAAI,EAAE,mBAAmB;EACzBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,wBAAwB,CAAC;EAChD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetSingletonEntry/index.d.ts

@@ -0,0 +1 @@
+export { GetSingletonEntryUseCase } from "./abstractions.js";

package/features/contentEntry/GetSingletonEntry/index.js

@@ -0,0 +1,3 @@
+export { GetSingletonEntryUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/contentEntry/GetSingletonEntry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetSingletonEntryUseCase"],"sources":["index.ts"],"sourcesContent":["export { GetSingletonEntryUseCase } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,wBAAwB","ignoreList":[]}

package/features/contentEntry/GetUniqueFieldValues/GetUniqueFieldValuesRepository.d.ts

@@ -0,0 +1,11 @@
+import { Result } from "@webiny/feature/api";
+import { GetUniqueFieldValuesRepository as RepositoryAbstraction, GetUniqueFieldValuesParams } from "./abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import type { CmsModel, CmsEntryUniqueValue } from "../../../types/index.js";
+declare class GetUniqueFieldValuesRepositoryImpl implements RepositoryAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: StorageOperations.Interface);
+    execute(model: CmsModel, params: GetUniqueFieldValuesParams): Promise<Result<CmsEntryUniqueValue[], RepositoryAbstraction.Error>>;
+}
+export declare const GetUniqueFieldValuesRepository: import("@webiny/di").Implementation<typeof GetUniqueFieldValuesRepositoryImpl>;
+export {};

package/features/contentEntry/GetUniqueFieldValues/GetUniqueFieldValuesRepository.js

@@ -0,0 +1,32 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { GetUniqueFieldValuesRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+class GetUniqueFieldValuesRepositoryImpl {
+  constructor(storageOperations) {
+    this.storageOperations = storageOperations;
+  }
+  async execute(model, params) {
+    const {
+      where,
+      fieldId
+    } = params;
+    try {
+      const values = await this.storageOperations.entries.getUniqueFieldValues(model, {
+        where,
+        fieldId
+      });
+      return Result.ok(values);
+    } catch (error) {
+      return Result.fail(new EntryPersistenceError(error));
+    }
+  }
+}
+export const GetUniqueFieldValuesRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: GetUniqueFieldValuesRepositoryImpl,
+  dependencies: [StorageOperations]
+});
+
+//# sourceMappingURL=GetUniqueFieldValuesRepository.js.map

package/features/contentEntry/GetUniqueFieldValues/GetUniqueFieldValuesRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","GetUniqueFieldValuesRepository","RepositoryAbstraction","StorageOperations","EntryPersistenceError","GetUniqueFieldValuesRepositoryImpl","constructor","storageOperations","execute","model","params","where","fieldId","values","entries","getUniqueFieldValues","ok","error","fail","abstraction","implementation","dependencies"],"sources":["GetUniqueFieldValuesRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport {\n    GetUniqueFieldValuesRepository as RepositoryAbstraction,\n    GetUniqueFieldValuesParams\n} from \"./abstractions.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\nimport type { CmsModel, CmsEntryUniqueValue } from \"~/types/index.js\";\n\nclass GetUniqueFieldValuesRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(private storageOperations: StorageOperations.Interface) {}\n\n    async execute(\n        model: CmsModel,\n        params: GetUniqueFieldValuesParams\n    ): Promise<Result<CmsEntryUniqueValue[], RepositoryAbstraction.Error>> {\n        const { where, fieldId } = params;\n\n        try {\n            const values = await this.storageOperations.entries.getUniqueFieldValues(model, {\n                where,\n                fieldId\n            });\n\n            return Result.ok(values);\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const GetUniqueFieldValuesRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: GetUniqueFieldValuesRepositoryImpl,\n    dependencies: [StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SACIC,8BAA8B,IAAIC,qBAAqB;AAG3D,SAASC,iBAAiB;AAC1B,SAASC,qBAAqB;AAG9B,MAAMC,kCAAkC,CAA4C;EACzEC,WAAWA,CAASC,iBAA8C,EAAE;IAAA,KAAhDA,iBAA8C,GAA9CA,iBAA8C;EAAG;EAE5E,MAAMC,OAAOA,CACTC,KAAe,EACfC,MAAkC,EACiC;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAQ,CAAC,GAAGF,MAAM;IAEjC,IAAI;MACA,MAAMG,MAAM,GAAG,MAAM,IAAI,CAACN,iBAAiB,CAACO,OAAO,CAACC,oBAAoB,CAACN,KAAK,EAAE;QAC5EE,KAAK;QACLC;MACJ,CAAC,CAAC;MAEF,OAAOb,MAAM,CAACiB,EAAE,CAACH,MAAM,CAAC;IAC5B,CAAC,CAAC,OAAOI,KAAK,EAAE;MACZ,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAId,qBAAqB,CAACa,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMhB,8BAA8B,GAAGD,oBAAoB,CAAC;EAC/DmB,WAAW,EAAEjB,qBAAqB;EAClCkB,cAAc,EAAEf,kCAAkC;EAClDgB,YAAY,EAAE,CAAClB,iBAAiB;AACpC,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetUniqueFieldValues/GetUniqueFieldValuesUseCase.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { GetUniqueFieldValuesUseCase as UseCaseAbstraction, GetUniqueFieldValuesRepository, GetUniqueFieldValuesParams } from "./abstractions.js";
+import { AccessControl, CmsContext } from "../../../features/shared/abstractions.js";
+import type { CmsModel, CmsEntryUniqueValue } from "../../../types/index.js";
+declare class GetUniqueFieldValuesUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private cmsContext;
+    constructor(repository: GetUniqueFieldValuesRepository.Interface, accessControl: AccessControl.Interface, cmsContext: CmsContext.Interface);
+    execute(model: CmsModel, params: GetUniqueFieldValuesParams): Promise<Result<CmsEntryUniqueValue[], UseCaseAbstraction.Error>>;
+}
+export declare const GetUniqueFieldValuesUseCase: import("@webiny/di").Implementation<typeof GetUniqueFieldValuesUseCaseImpl>;
+export {};

package/features/contentEntry/GetUniqueFieldValues/GetUniqueFieldValuesUseCase.js

@@ -0,0 +1,78 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { GetUniqueFieldValuesUseCase as UseCaseAbstraction, GetUniqueFieldValuesRepository } from "./abstractions.js";
+import { AccessControl, CmsContext } from "../../shared/abstractions.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { FieldNotSearchableError, InvalidWhereConditionError } from "./errors.js";
+import { getSearchableFields } from "../../../crud/contentEntry/searchableFields.js";
+class GetUniqueFieldValuesUseCaseImpl {
+  constructor(repository, accessControl, cmsContext) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+    this.cmsContext = cmsContext;
+  }
+  async execute(model, params) {
+    // Check access control - throws if not authorized
+    try {
+      await this.accessControl.ensureCanAccessEntry({
+        model
+      });
+    } catch (error) {
+      if (error instanceof EntryNotAuthorizedError) {
+        return Result.fail(error);
+      }
+      throw error;
+    }
+    const {
+      where: initialWhere,
+      fieldId
+    } = params;
+    const where = {
+      ...initialWhere
+    };
+
+    // Apply ownership filter if needed
+    const canAccessOnlyOwned = await this.accessControl.canAccessOnlyOwnedEntries({
+      model
+    });
+    if (canAccessOnlyOwned) {
+      const identity = this.cmsContext.security.getIdentity();
+      where.createdBy = identity.id;
+    }
+
+    // Validate where conditions
+    if (where.latest && where.published) {
+      return Result.fail(new InvalidWhereConditionError("Cannot list entries that are both published and latest.", where));
+    }
+    if (!where.latest && !where.published) {
+      return Result.fail(new InvalidWhereConditionError("Cannot list entries if we do not have latest or published defined.", where));
+    }
+
+    // Verify the field is searchable
+    const searchableFields = getSearchableFields({
+      fields: model.fields,
+      plugins: this.cmsContext.plugins,
+      input: []
+    });
+    if (!searchableFields.includes(fieldId)) {
+      return Result.fail(new FieldNotSearchableError(fieldId));
+    }
+
+    // Execute repository call
+    const result = await this.repository.execute(model, {
+      where,
+      fieldId
+    });
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    return Result.ok(result.value);
+  }
+}
+export const GetUniqueFieldValuesUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: GetUniqueFieldValuesUseCaseImpl,
+  dependencies: [GetUniqueFieldValuesRepository, AccessControl, CmsContext]
+});
+
+//# sourceMappingURL=GetUniqueFieldValuesUseCase.js.map

package/features/contentEntry/GetUniqueFieldValues/GetUniqueFieldValuesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","GetUniqueFieldValuesUseCase","UseCaseAbstraction","GetUniqueFieldValuesRepository","AccessControl","CmsContext","EntryNotAuthorizedError","FieldNotSearchableError","InvalidWhereConditionError","getSearchableFields","GetUniqueFieldValuesUseCaseImpl","constructor","repository","accessControl","cmsContext","execute","model","params","ensureCanAccessEntry","error","fail","where","initialWhere","fieldId","canAccessOnlyOwned","canAccessOnlyOwnedEntries","identity","security","getIdentity","createdBy","id","latest","published","searchableFields","fields","plugins","input","includes","result","isFail","ok","value","abstraction","implementation","dependencies"],"sources":["GetUniqueFieldValuesUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport {\n    GetUniqueFieldValuesUseCase as UseCaseAbstraction,\n    GetUniqueFieldValuesRepository,\n    GetUniqueFieldValuesParams\n} from \"./abstractions.js\";\nimport { AccessControl, CmsContext } from \"~/features/shared/abstractions.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { FieldNotSearchableError, InvalidWhereConditionError } from \"./errors.js\";\nimport { getSearchableFields } from \"~/crud/contentEntry/searchableFields.js\";\nimport type { CmsModel, CmsEntryUniqueValue } from \"~/types/index.js\";\n\nclass GetUniqueFieldValuesUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: GetUniqueFieldValuesRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private cmsContext: CmsContext.Interface\n    ) {}\n\n    async execute(\n        model: CmsModel,\n        params: GetUniqueFieldValuesParams\n    ): Promise<Result<CmsEntryUniqueValue[], UseCaseAbstraction.Error>> {\n        // Check access control - throws if not authorized\n        try {\n            await this.accessControl.ensureCanAccessEntry({ model });\n        } catch (error) {\n            if (error instanceof EntryNotAuthorizedError) {\n                return Result.fail(error);\n            }\n            throw error;\n        }\n\n        const { where: initialWhere, fieldId } = params;\n\n        const where = {\n            ...initialWhere\n        };\n\n        // Apply ownership filter if needed\n        const canAccessOnlyOwned = await this.accessControl.canAccessOnlyOwnedEntries({ model });\n        if (canAccessOnlyOwned) {\n            const identity = this.cmsContext.security.getIdentity();\n            where.createdBy = identity.id;\n        }\n\n        // Validate where conditions\n        if (where.latest && where.published) {\n            return Result.fail(\n                new InvalidWhereConditionError(\n                    \"Cannot list entries that are both published and latest.\",\n                    where\n                )\n            );\n        }\n\n        if (!where.latest && !where.published) {\n            return Result.fail(\n                new InvalidWhereConditionError(\n                    \"Cannot list entries if we do not have latest or published defined.\",\n                    where\n                )\n            );\n        }\n\n        // Verify the field is searchable\n        const searchableFields = getSearchableFields({\n            fields: model.fields,\n            plugins: this.cmsContext.plugins,\n            input: []\n        });\n\n        if (!searchableFields.includes(fieldId)) {\n            return Result.fail(new FieldNotSearchableError(fieldId));\n        }\n\n        // Execute repository call\n        const result = await this.repository.execute(model, { where, fieldId });\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const GetUniqueFieldValuesUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetUniqueFieldValuesUseCaseImpl,\n    dependencies: [GetUniqueFieldValuesRepository, AccessControl, CmsContext]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,50 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntryUniqueValue, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+import type { FieldNotSearchableError, InvalidWhereConditionError } from "./errors.js";
+export interface GetUniqueFieldValuesParams {
+    where: {
+        latest?: boolean;
+        published?: boolean;
+        createdBy?: string;
+        [key: string]: any;
+    };
+    fieldId: string;
+}
+/**
+ * GetUniqueFieldValues Use Case - Fetches unique values for a specific field.
+ * Used for filtering/autocomplete in the UI.
+ */
+export interface IGetUniqueFieldValuesUseCase {
+    execute(model: CmsModel, params: GetUniqueFieldValuesParams): Promise<Result<CmsEntryUniqueValue[], UseCaseError>>;
+}
+export interface IGetUniqueFieldValuesUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    storage: EntryPersistenceError;
+    fieldNotSearchable: FieldNotSearchableError;
+    invalidWhere: InvalidWhereConditionError;
+}
+type UseCaseError = IGetUniqueFieldValuesUseCaseErrors[keyof IGetUniqueFieldValuesUseCaseErrors];
+export declare const GetUniqueFieldValuesUseCase: import("@webiny/di").Abstraction<IGetUniqueFieldValuesUseCase>;
+export declare namespace GetUniqueFieldValuesUseCase {
+    type Interface = IGetUniqueFieldValuesUseCase;
+    type Params = GetUniqueFieldValuesParams;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsEntryUniqueValue[], UseCaseError>>;
+}
+/**
+ * GetUniqueFieldValuesRepository - Fetches unique field values from storage.
+ */
+export interface IGetUniqueFieldValuesRepository {
+    execute(model: CmsModel, params: GetUniqueFieldValuesParams): Promise<Result<CmsEntryUniqueValue[], RepositoryError>>;
+}
+export interface IGetUniqueFieldValuesRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IGetUniqueFieldValuesRepositoryErrors[keyof IGetUniqueFieldValuesRepositoryErrors];
+export declare const GetUniqueFieldValuesRepository: import("@webiny/di").Abstraction<IGetUniqueFieldValuesRepository>;
+export declare namespace GetUniqueFieldValuesRepository {
+    type Interface = IGetUniqueFieldValuesRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/GetUniqueFieldValues/abstractions.js

@@ -0,0 +1,16 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetUniqueFieldValues Use Case - Fetches unique values for a specific field.
+ * Used for filtering/autocomplete in the UI.
+ */
+
+export const GetUniqueFieldValuesUseCase = createAbstraction("GetUniqueFieldValuesUseCase");
+
+/**
+ * GetUniqueFieldValuesRepository - Fetches unique field values from storage.
+ */
+
+export const GetUniqueFieldValuesRepository = createAbstraction("GetUniqueFieldValuesRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetUniqueFieldValuesUseCase","GetUniqueFieldValuesRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntryUniqueValue, CmsModel } from \"~/types/index.js\";\nimport type {\n    EntryNotAuthorizedError,\n    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\nimport type { FieldNotSearchableError, InvalidWhereConditionError } from \"./errors.js\";\n\nexport interface GetUniqueFieldValuesParams {\n    where: {\n        latest?: boolean;\n        published?: boolean;\n        createdBy?: string;\n        [key: string]: any;\n    };\n    fieldId: string;\n}\n\n/**\n * GetUniqueFieldValues Use Case - Fetches unique values for a specific field.\n * Used for filtering/autocomplete in the UI.\n */\nexport interface IGetUniqueFieldValuesUseCase {\n    execute(\n        model: CmsModel,\n        params: GetUniqueFieldValuesParams\n    ): Promise<Result<CmsEntryUniqueValue[], UseCaseError>>;\n}\n\nexport interface IGetUniqueFieldValuesUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    storage: EntryPersistenceError;\n    fieldNotSearchable: FieldNotSearchableError;\n    invalidWhere: InvalidWhereConditionError;\n}\n\ntype UseCaseError = IGetUniqueFieldValuesUseCaseErrors[keyof IGetUniqueFieldValuesUseCaseErrors];\n\nexport const GetUniqueFieldValuesUseCase = createAbstraction<IGetUniqueFieldValuesUseCase>(\n    \"GetUniqueFieldValuesUseCase\"\n);\n\nexport namespace GetUniqueFieldValuesUseCase {\n    export type Interface = IGetUniqueFieldValuesUseCase;\n    export type Params = GetUniqueFieldValuesParams;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsEntryUniqueValue[], UseCaseError>>;\n}\n\n/**\n * GetUniqueFieldValuesRepository - Fetches unique field values from storage.\n */\nexport interface IGetUniqueFieldValuesRepository {\n    execute(\n        model: CmsModel,\n        params: GetUniqueFieldValuesParams\n    ): Promise<Result<CmsEntryUniqueValue[], RepositoryError>>;\n}\n\nexport interface IGetUniqueFieldValuesRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError =\n    IGetUniqueFieldValuesRepositoryErrors[keyof IGetUniqueFieldValuesRepositoryErrors];\n\nexport const GetUniqueFieldValuesRepository = createAbstraction<IGetUniqueFieldValuesRepository>(\n    \"GetUniqueFieldValuesRepository\"\n);\n\nexport namespace GetUniqueFieldValuesRepository {\n    export type Interface = IGetUniqueFieldValuesRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAkB/D;AACA;AACA;AACA;;AAiBA,OAAO,MAAMC,2BAA2B,GAAGD,iBAAiB,CACxD,6BACJ,CAAC;;AAUD;AACA;AACA;;AAeA,OAAO,MAAME,8BAA8B,GAAGF,iBAAiB,CAC3D,gCACJ,CAAC","ignoreList":[]}

package/features/contentEntry/GetUniqueFieldValues/errors.d.ts

@@ -0,0 +1,16 @@
+import { BaseError } from "@webiny/feature/api";
+type FieldNotSearchableErrorData = {
+    fieldId: string;
+};
+export declare class FieldNotSearchableError extends BaseError<FieldNotSearchableErrorData> {
+    readonly code: "Cms/Entry/FieldNotSearchable";
+    constructor(fieldId: string);
+}
+type InvalidWhereConditionErrorData = {
+    where: Record<string, any>;
+};
+export declare class InvalidWhereConditionError extends BaseError<InvalidWhereConditionErrorData> {
+    readonly code: "Cms/Entry/InvalidWhereCondition";
+    constructor(message: string, where: Record<string, any>);
+}
+export {};

package/features/contentEntry/GetUniqueFieldValues/errors.js

@@ -0,0 +1,25 @@
+import { BaseError } from "@webiny/feature/api";
+export class FieldNotSearchableError extends BaseError {
+  code = "Cms/Entry/FieldNotSearchable";
+  constructor(fieldId) {
+    super({
+      message: `Cannot list unique entry field values if the field "${fieldId}" is not searchable.`,
+      data: {
+        fieldId
+      }
+    });
+  }
+}
+export class InvalidWhereConditionError extends BaseError {
+  code = "Cms/Entry/InvalidWhereCondition";
+  constructor(message, where) {
+    super({
+      message,
+      data: {
+        where
+      }
+    });
+  }
+}
+
+//# sourceMappingURL=errors.js.map

package/features/contentEntry/GetUniqueFieldValues/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","FieldNotSearchableError","code","constructor","fieldId","message","data","InvalidWhereConditionError","where"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\ntype FieldNotSearchableErrorData = {\n    fieldId: string;\n};\n\nexport class FieldNotSearchableError extends BaseError<FieldNotSearchableErrorData> {\n    override readonly code = \"Cms/Entry/FieldNotSearchable\" as const;\n\n    public constructor(fieldId: string) {\n        super({\n            message: `Cannot list unique entry field values if the field \"${fieldId}\" is not searchable.`,\n            data: { fieldId }\n        });\n    }\n}\n\ntype InvalidWhereConditionErrorData = {\n    where: Record<string, any>;\n};\n\nexport class InvalidWhereConditionError extends BaseError<InvalidWhereConditionErrorData> {\n    override readonly code = \"Cms/Entry/InvalidWhereCondition\" as const;\n\n    public constructor(message: string, where: Record<string, any>) {\n        super({\n            message,\n            data: { where }\n        });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAM/C,OAAO,MAAMC,uBAAuB,SAASD,SAAS,CAA8B;EAC9DE,IAAI,GAAG,8BAA8B;EAEhDC,WAAWA,CAACC,OAAe,EAAE;IAChC,KAAK,CAAC;MACFC,OAAO,EAAE,uDAAuDD,OAAO,sBAAsB;MAC7FE,IAAI,EAAE;QAAEF;MAAQ;IACpB,CAAC,CAAC;EACN;AACJ;AAMA,OAAO,MAAMG,0BAA0B,SAASP,SAAS,CAAiC;EACpEE,IAAI,GAAG,iCAAiC;EAEnDC,WAAWA,CAACE,OAAe,EAAEG,KAA0B,EAAE;IAC5D,KAAK,CAAC;MACFH,OAAO;MACPC,IAAI,EAAE;QAAEE;MAAM;IAClB,CAAC,CAAC;EACN;AACJ","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const GetUniqueFieldValuesFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentEntry/GetUniqueFieldValues/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetUniqueFieldValuesUseCase } from "./GetUniqueFieldValuesUseCase.js";
+import { GetUniqueFieldValuesRepository } from "./GetUniqueFieldValuesRepository.js";
+export const GetUniqueFieldValuesFeature = createFeature({
+  name: "GetUniqueFieldValues",
+  register(container) {
+    container.register(GetUniqueFieldValuesUseCase);
+    container.register(GetUniqueFieldValuesRepository).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetUniqueFieldValuesUseCase","GetUniqueFieldValuesRepository","GetUniqueFieldValuesFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetUniqueFieldValuesUseCase } from \"./GetUniqueFieldValuesUseCase.js\";\nimport { GetUniqueFieldValuesRepository } from \"./GetUniqueFieldValuesRepository.js\";\n\nexport const GetUniqueFieldValuesFeature = createFeature({\n    name: \"GetUniqueFieldValues\",\n    register(container) {\n        container.register(GetUniqueFieldValuesUseCase);\n        container.register(GetUniqueFieldValuesRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,2BAA2B;AACpC,SAASC,8BAA8B;AAEvC,OAAO,MAAMC,2BAA2B,GAAGH,aAAa,CAAC;EACrDI,IAAI,EAAE,sBAAsB;EAC5BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,2BAA2B,CAAC;IAC/CK,SAAS,CAACD,QAAQ,CAACH,8BAA8B,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACzE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetUniqueFieldValues/index.d.ts

@@ -0,0 +1 @@
+export { GetUniqueFieldValuesUseCase, GetUniqueFieldValuesRepository } from "./abstractions.js";

package/features/contentEntry/GetUniqueFieldValues/index.js

@@ -0,0 +1,3 @@
+export { GetUniqueFieldValuesUseCase, GetUniqueFieldValuesRepository } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/contentEntry/GetUniqueFieldValues/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetUniqueFieldValuesUseCase","GetUniqueFieldValuesRepository"],"sources":["index.ts"],"sourcesContent":["export { GetUniqueFieldValuesUseCase, GetUniqueFieldValuesRepository } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,2BAA2B,EAAEC,8BAA8B","ignoreList":[]}