@webiny/languages 0.0.0-unstable.0d717d18dd

package/admin/features/listLanguages/feature.js

@@ -0,0 +1,31 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ListCache } from "@webiny/app-admin/features/listCache/index.js";
+import { LanguagesCache, ListLanguagesRepository, ListLanguagesUseCase } from "./abstractions.js";
+import { ListLanguagesUseCase as external_ListLanguagesUseCase_js_ListLanguagesUseCase } from "./ListLanguagesUseCase.js";
+import { ListLanguagesRepository as external_ListLanguagesRepository_js_ListLanguagesRepository } from "./ListLanguagesRepository.js";
+import { ListLanguagesGateway } from "./ListLanguagesGateway.js";
+import { LanguageEntryAfterCreateHandler } from "./LanguageEntryAfterCreateHandler.js";
+import { LanguageEntryAfterUpdateHandler } from "./LanguageEntryAfterUpdateHandler.js";
+import { LanguageEntryAfterDeleteHandler } from "./LanguageEntryAfterDeleteHandler.js";
+const ListLanguagesFeature = createFeature({
+    name: "Languages/ListLanguages",
+    register (container) {
+        container.registerInstance(LanguagesCache, new ListCache());
+        container.register(external_ListLanguagesUseCase_js_ListLanguagesUseCase);
+        container.register(external_ListLanguagesRepository_js_ListLanguagesRepository).inSingletonScope();
+        container.register(ListLanguagesGateway).inSingletonScope();
+        container.register(LanguageEntryAfterCreateHandler);
+        container.register(LanguageEntryAfterUpdateHandler);
+        container.register(LanguageEntryAfterDeleteHandler);
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ListLanguagesUseCase),
+            repository: container.resolve(ListLanguagesRepository),
+            cache: container.resolve(LanguagesCache)
+        };
+    }
+});
+export { ListLanguagesFeature };
+
+//# sourceMappingURL=feature.js.map

package/admin/features/listLanguages/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/features/listLanguages/feature.js","sources":["../../../../src/admin/features/listLanguages/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ListCache } from \"@webiny/app-admin/features/listCache/index.js\";\nimport {\n    ListLanguagesUseCase as UseCaseAbstraction,\n    ListLanguagesRepository as RepositoryAbstraction,\n    LanguagesCache\n} from \"./abstractions.js\";\nimport type { LanguageDto } from \"./abstractions.js\";\nimport { ListLanguagesUseCase } from \"./ListLanguagesUseCase.js\";\nimport { ListLanguagesRepository } from \"./ListLanguagesRepository.js\";\nimport { ListLanguagesGateway } from \"./ListLanguagesGateway.js\";\nimport { LanguageEntryAfterCreateHandler } from \"./LanguageEntryAfterCreateHandler.js\";\nimport { LanguageEntryAfterUpdateHandler } from \"./LanguageEntryAfterUpdateHandler.js\";\nimport { LanguageEntryAfterDeleteHandler } from \"./LanguageEntryAfterDeleteHandler.js\";\n\nexport const ListLanguagesFeature = createFeature({\n    name: \"Languages/ListLanguages\",\n    register(container) {\n        container.registerInstance(LanguagesCache, new ListCache<LanguageDto>());\n        container.register(ListLanguagesUseCase);\n        container.register(ListLanguagesRepository).inSingletonScope();\n        container.register(ListLanguagesGateway).inSingletonScope();\n        container.register(LanguageEntryAfterCreateHandler);\n        container.register(LanguageEntryAfterUpdateHandler);\n        container.register(LanguageEntryAfterDeleteHandler);\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCaseAbstraction),\n            repository: container.resolve(RepositoryAbstraction),\n            cache: container.resolve(LanguagesCache)\n        };\n    }\n});\n"],"names":["ListLanguagesFeature","createFeature","container","LanguagesCache","ListCache","ListLanguagesUseCase","ListLanguagesRepository","ListLanguagesGateway","LanguageEntryAfterCreateHandler","LanguageEntryAfterUpdateHandler","LanguageEntryAfterDeleteHandler","UseCaseAbstraction","RepositoryAbstraction"],"mappings":";;;;;;;;;AAeO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,gBAAgB,CAACC,gBAAgB,IAAIC;QAC/CF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI,6DAAyB,gBAAgB;QAC5DJ,UAAU,QAAQ,CAACK,sBAAsB,gBAAgB;QACzDL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;IACvB;IACA,SAAQR,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACS;YAC3B,YAAYT,UAAU,OAAO,CAACU;YAC9B,OAAOV,UAAU,OAAO,CAACC;QAC7B;IACJ;AACJ"}

package/admin/features/listLanguages/index.d.ts

@@ -0,0 +1,2 @@
+export { ListLanguagesFeature } from "./feature.js";
+export type { LanguageDto } from "./abstractions.js";

package/admin/features/listLanguages/index.js

@@ -0,0 +1 @@
+export { ListLanguagesFeature } from "./feature.js";

package/admin/features/listLanguages/toLanguageDto.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageDto } from "./abstractions.js";
+import type { CmsContentEntry } from "@webiny/app-headless-cms/types.js";
+export declare function toLanguageDto(entry: CmsContentEntry): LanguageDto;

package/admin/features/listLanguages/toLanguageDto.js

@@ -0,0 +1,13 @@
+function toLanguageDto(entry) {
+    return {
+        id: entry.entryId,
+        code: entry.values.code,
+        name: entry.values.name,
+        direction: entry.values.direction,
+        isDefault: entry.values.isDefault,
+        enabled: entry.values.enabled
+    };
+}
+export { toLanguageDto };
+
+//# sourceMappingURL=toLanguageDto.js.map

package/admin/features/listLanguages/toLanguageDto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/features/listLanguages/toLanguageDto.js","sources":["../../../../src/admin/features/listLanguages/toLanguageDto.ts"],"sourcesContent":["import type { LanguageDto } from \"./abstractions.js\";\nimport type { CmsContentEntry } from \"@webiny/app-headless-cms/types.js\";\n\nexport function toLanguageDto(entry: CmsContentEntry): LanguageDto {\n    return {\n        id: entry.entryId,\n        code: entry.values.code,\n        name: entry.values.name,\n        direction: entry.values.direction,\n        isDefault: entry.values.isDefault,\n        enabled: entry.values.enabled\n    };\n}\n"],"names":["toLanguageDto","entry"],"mappings":"AAGO,SAASA,cAAcC,KAAsB;IAChD,OAAO;QACH,IAAIA,MAAM,OAAO;QACjB,MAAMA,MAAM,MAAM,CAAC,IAAI;QACvB,MAAMA,MAAM,MAAM,CAAC,IAAI;QACvB,WAAWA,MAAM,MAAM,CAAC,SAAS;QACjC,WAAWA,MAAM,MAAM,CAAC,SAAS;QACjC,SAASA,MAAM,MAAM,CAAC,OAAO;IACjC;AACJ"}

package/admin/presentation/hooks/useLanguages.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageDto } from "../../../admin/features/listLanguages/index.js";
+export declare const useLanguages: () => {
+    loading: boolean;
+    languages: LanguageDto[];
+};

package/admin/presentation/hooks/useLanguages.js

@@ -0,0 +1,27 @@
+import { useEffect, useState } from "react";
+import { autorun } from "mobx";
+import { useFeature } from "@webiny/app";
+import { ListLanguagesFeature } from "../../features/listLanguages/index.js";
+const useLanguages = ()=>{
+    const { useCase, cache } = useFeature(ListLanguagesFeature);
+    const [languages, setLanguages] = useState([]);
+    const [loading, setLoading] = useState(true);
+    useEffect(()=>{
+        useCase.execute().then(()=>{
+            setLoading(false);
+        });
+        return autorun(()=>{
+            setLanguages(cache.getItems());
+        });
+    }, [
+        useCase,
+        cache
+    ]);
+    return {
+        loading,
+        languages
+    };
+};
+export { useLanguages };
+
+//# sourceMappingURL=useLanguages.js.map

package/admin/presentation/hooks/useLanguages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/presentation/hooks/useLanguages.js","sources":["../../../../src/admin/presentation/hooks/useLanguages.tsx"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { autorun } from \"mobx\";\nimport { useFeature } from \"@webiny/app\";\nimport { ListLanguagesFeature } from \"~/admin/features/listLanguages/index.js\";\nimport type { LanguageDto } from \"~/admin/features/listLanguages/index.js\";\n\nexport const useLanguages = () => {\n    const { useCase, cache } = useFeature(ListLanguagesFeature);\n    const [languages, setLanguages] = useState<LanguageDto[]>([]);\n    const [loading, setLoading] = useState(true);\n\n    useEffect(() => {\n        useCase.execute().then(() => {\n            setLoading(false);\n        });\n\n        return autorun(() => {\n            setLanguages(cache.getItems());\n        });\n    }, [useCase, cache]);\n\n    return { loading, languages };\n};\n"],"names":["useLanguages","useCase","cache","useFeature","ListLanguagesFeature","languages","setLanguages","useState","loading","setLoading","useEffect","autorun"],"mappings":";;;;AAMO,MAAMA,eAAe;IACxB,MAAM,EAAEC,OAAO,EAAEC,KAAK,EAAE,GAAGC,WAAWC;IACtC,MAAM,CAACC,WAAWC,aAAa,GAAGC,SAAwB,EAAE;IAC5D,MAAM,CAACC,SAASC,WAAW,GAAGF,SAAS;IAEvCG,UAAU;QACNT,QAAQ,OAAO,GAAG,IAAI,CAAC;YACnBQ,WAAW;QACf;QAEA,OAAOE,QAAQ;YACXL,aAAaJ,MAAM,QAAQ;QAC/B;IACJ,GAAG;QAACD;QAASC;KAAM;IAEnB,OAAO;QAAEM;QAASH;IAAU;AAChC"}

package/api/Extension.d.ts

@@ -0,0 +1,4 @@
+export declare const Extension: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/Extension.js

@@ -0,0 +1,25 @@
+import { createFeature } from "@webiny/feature/api";
+import LanguageModel from "./domain/LanguageModel.js";
+import { EnsureSingleDefaultLanguageFeature } from "./features/EnsureSingleDefaultLanguage/feature.js";
+import { GetDefaultLanguageFeature } from "./features/GetDefaultLanguage/feature.js";
+import { GetLanguageByCodeFeature } from "./features/GetLanguageByCode/feature.js";
+import { ListLanguagesFeature } from "./features/ListLanguages/feature.js";
+import { LanguagesGraphQLSchema } from "./graphql/LanguagesGraphQLSchema.js";
+import { AddCmsPermissionsFeature } from "./features/AddCmsPermissions/feature.js";
+import { LanguagesPermissionsFeature } from "./features/Permissions/feature.js";
+const Extension = createFeature({
+    name: "Languages",
+    register (container) {
+        container.register(LanguageModel);
+        EnsureSingleDefaultLanguageFeature.register(container);
+        GetDefaultLanguageFeature.register(container);
+        GetLanguageByCodeFeature.register(container);
+        ListLanguagesFeature.register(container);
+        AddCmsPermissionsFeature.register(container);
+        LanguagesPermissionsFeature.register(container);
+        container.register(LanguagesGraphQLSchema);
+    }
+});
+export { Extension };
+
+//# sourceMappingURL=Extension.js.map

package/api/Extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/Extension.js","sources":["../../src/api/Extension.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport LanguageModel from \"./domain/LanguageModel.js\";\nimport { EnsureSingleDefaultLanguageFeature } from \"./features/EnsureSingleDefaultLanguage/feature.js\";\nimport { GetDefaultLanguageFeature } from \"./features/GetDefaultLanguage/feature.js\";\nimport { GetLanguageByCodeFeature } from \"./features/GetLanguageByCode/feature.js\";\nimport { ListLanguagesFeature } from \"./features/ListLanguages/feature.js\";\nimport { LanguagesGraphQLSchema } from \"./graphql/LanguagesGraphQLSchema.js\";\nimport { AddCmsPermissionsFeature } from \"~/api/features/AddCmsPermissions/feature.js\";\nimport { LanguagesPermissionsFeature } from \"~/api/features/Permissions/feature.js\";\n\nexport const Extension = createFeature({\n    name: \"Languages\",\n    register(container) {\n        container.register(LanguageModel);\n\n        // Features\n        EnsureSingleDefaultLanguageFeature.register(container);\n        GetDefaultLanguageFeature.register(container);\n        GetLanguageByCodeFeature.register(container);\n        ListLanguagesFeature.register(container);\n        AddCmsPermissionsFeature.register(container);\n        LanguagesPermissionsFeature.register(container);\n\n        // GraphQL\n        container.register(LanguagesGraphQLSchema);\n    }\n});\n"],"names":["Extension","createFeature","container","LanguageModel","EnsureSingleDefaultLanguageFeature","GetDefaultLanguageFeature","GetLanguageByCodeFeature","ListLanguagesFeature","AddCmsPermissionsFeature","LanguagesPermissionsFeature","LanguagesGraphQLSchema"],"mappings":";;;;;;;;;AAUO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QAGnBC,mCAAmC,QAAQ,CAACF;QAC5CG,0BAA0B,QAAQ,CAACH;QACnCI,yBAAyB,QAAQ,CAACJ;QAClCK,qBAAqB,QAAQ,CAACL;QAC9BM,yBAAyB,QAAQ,CAACN;QAClCO,4BAA4B,QAAQ,CAACP;QAGrCA,UAAU,QAAQ,CAACQ;IACvB;AACJ"}

package/api/domain/Language.d.ts

@@ -0,0 +1,8 @@
+export interface Language {
+    id: string;
+    name: string;
+    code: string;
+    direction: "ltr" | "rtl";
+    isDefault: boolean;
+    enabled: boolean;
+}

package/api/domain/LanguageModel.d.ts

@@ -0,0 +1,8 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+declare class LanguageModelFactory implements ModelFactory.Interface {
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PublicModelBuilder[]>;
+}
+declare const _default: typeof LanguageModelFactory & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions").IModelFactory>;
+};
+export default _default;

package/api/domain/LanguageModel.js

@@ -0,0 +1,56 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { LANGUAGE_MODEL_ID } from "../../shared/constants.js";
+class LanguageModelFactory {
+    async execute(builder) {
+        const model = builder.public({
+            modelId: LANGUAGE_MODEL_ID,
+            name: "Language",
+            group: "hidden"
+        }).description("Manage system languages.").titleFieldId("name").icon("fas/language").singularApiName("Language").pluralApiName("Languages").tags([
+            "$publishing:false",
+            "$hidden:true"
+        ]);
+        model.fields((fields)=>({
+                name: fields.text().label("Name").description("The display name for this language (e.g., German, English, Arabic).").required().renderer("textInput"),
+                code: fields.text().label("Code").description("A unique language or locale code used for URL routing and identifying content (e.g., en, de, pt-BR).").required().renderer("textInput"),
+                direction: fields.text().label("Direction").description("Controls the text direction. Most languages read left-to-right, but some (like Arabic and Hebrew) read right-to-left.").defaultValue("ltr").renderer("select").required().predefinedValues([
+                    {
+                        value: "ltr",
+                        label: "LTR"
+                    },
+                    {
+                        value: "rtl",
+                        label: "RTL"
+                    }
+                ]),
+                isDefault: fields.boolean().label("Is default?").description("Make this the primary language. Default language content is shown when no specific language is requested.").defaultValue(false).renderer("switch"),
+                enabled: fields.boolean().label("Is enabled?").description("Disabled languages are hidden from the public site but can still be configured and translated in the admin.").defaultValue(false).renderer("switch")
+            })).layout([
+            [
+                "name"
+            ],
+            [
+                "code"
+            ],
+            [
+                "direction"
+            ],
+            [
+                "isDefault"
+            ],
+            [
+                "enabled"
+            ]
+        ]);
+        return [
+            model
+        ];
+    }
+}
+const LanguageModel = ModelFactory.createImplementation({
+    implementation: LanguageModelFactory,
+    dependencies: []
+});
+export default LanguageModel;
+
+//# sourceMappingURL=LanguageModel.js.map

package/api/domain/LanguageModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/LanguageModel.js","sources":["../../../src/api/domain/LanguageModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\nimport { LANGUAGE_MODEL_ID } from \"~/shared/constants.js\";\n\nclass LanguageModelFactory implements ModelFactory.Interface {\n    async execute(builder: ModelFactory.Builder) {\n        const model = builder\n            .public({\n                modelId: LANGUAGE_MODEL_ID,\n                name: \"Language\",\n                group: \"hidden\"\n            })\n            .description(\"Manage system languages.\")\n            .titleFieldId(\"name\")\n            .icon(\"fas/language\")\n            .singularApiName(\"Language\")\n            .pluralApiName(\"Languages\")\n            .tags([\"$publishing:false\", \"$hidden:true\"]);\n\n        model\n            .fields(fields => ({\n                name: fields\n                    .text()\n                    .label(\"Name\")\n                    .description(\n                        \"The display name for this language (e.g., German, English, Arabic).\"\n                    )\n                    .required()\n                    .renderer(\"textInput\"),\n                code: fields\n                    .text()\n                    .label(\"Code\")\n                    .description(\n                        \"A unique language or locale code used for URL routing and identifying content (e.g., en, de, pt-BR).\"\n                    )\n                    .required()\n                    .renderer(\"textInput\"),\n                direction: fields\n                    .text()\n                    .label(\"Direction\")\n                    .description(\n                        \"Controls the text direction. Most languages read left-to-right, but some (like Arabic and Hebrew) read right-to-left.\"\n                    )\n                    .defaultValue(\"ltr\")\n                    .renderer(\"select\")\n                    .required()\n                    .predefinedValues([\n                        {\n                            value: \"ltr\",\n                            label: \"LTR\"\n                        },\n                        {\n                            value: \"rtl\",\n                            label: \"RTL\"\n                        }\n                    ]),\n                isDefault: fields\n                    .boolean()\n                    .label(\"Is default?\")\n                    .description(\n                        \"Make this the primary language. Default language content is shown when no specific language is requested.\"\n                    )\n                    .defaultValue(false)\n                    .renderer(\"switch\"),\n                enabled: fields\n                    .boolean()\n                    .label(\"Is enabled?\")\n                    .description(\n                        \"Disabled languages are hidden from the public site but can still be configured and translated in the admin.\"\n                    )\n                    .defaultValue(false)\n                    .renderer(\"switch\")\n            }))\n            .layout([[\"name\"], [\"code\"], [\"direction\"], [\"isDefault\"], [\"enabled\"]]);\n\n        return [model];\n    }\n}\n\nexport default ModelFactory.createImplementation({\n    implementation: LanguageModelFactory,\n    dependencies: []\n});\n"],"names":["LanguageModelFactory","builder","model","LANGUAGE_MODEL_ID","fields","ModelFactory"],"mappings":";;AAGA,MAAMA;IACF,MAAM,QAAQC,OAA6B,EAAE;QACzC,MAAMC,QAAQD,QACT,MAAM,CAAC;YACJ,SAASE;YACT,MAAM;YACN,OAAO;QACX,GACC,WAAW,CAAC,4BACZ,YAAY,CAAC,QACb,IAAI,CAAC,gBACL,eAAe,CAAC,YAChB,aAAa,CAAC,aACd,IAAI,CAAC;YAAC;YAAqB;SAAe;QAE/CD,MACK,MAAM,CAACE,CAAAA,SAAW;gBACf,MAAMA,OACD,IAAI,GACJ,KAAK,CAAC,QACN,WAAW,CACR,uEAEH,QAAQ,GACR,QAAQ,CAAC;gBACd,MAAMA,OACD,IAAI,GACJ,KAAK,CAAC,QACN,WAAW,CACR,wGAEH,QAAQ,GACR,QAAQ,CAAC;gBACd,WAAWA,OACN,IAAI,GACJ,KAAK,CAAC,aACN,WAAW,CACR,yHAEH,YAAY,CAAC,OACb,QAAQ,CAAC,UACT,QAAQ,GACR,gBAAgB,CAAC;oBACd;wBACI,OAAO;wBACP,OAAO;oBACX;oBACA;wBACI,OAAO;wBACP,OAAO;oBACX;iBACH;gBACL,WAAWA,OACN,OAAO,GACP,KAAK,CAAC,eACN,WAAW,CACR,6GAEH,YAAY,CAAC,OACb,QAAQ,CAAC;gBACd,SAASA,OACJ,OAAO,GACP,KAAK,CAAC,eACN,WAAW,CACR,+GAEH,YAAY,CAAC,OACb,QAAQ,CAAC;YAClB,IACC,MAAM,CAAC;YAAC;gBAAC;aAAO;YAAE;gBAAC;aAAO;YAAE;gBAAC;aAAY;YAAE;gBAAC;aAAY;YAAE;gBAAC;aAAU;SAAC;QAE3E,OAAO;YAACF;SAAM;IAClB;AACJ;AAEA,sBAAeG,aAAa,oBAAoB,CAAC;IAC7C,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/api/domain/errors.d.ts

@@ -0,0 +1,15 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class LanguageNotFoundError extends BaseError<{
+    code: string;
+}> {
+    readonly code: "Languages/NotFound";
+    constructor(languageCode: string);
+}
+export declare class DefaultLanguageNotFoundError extends BaseError {
+    readonly code: "Languages/DefaultNotFound";
+    constructor();
+}
+export declare class LanguagePersistenceError extends BaseError {
+    readonly code: "Languages/PersistenceError";
+    constructor(error: Error);
+}

package/api/domain/errors.js

@@ -0,0 +1,28 @@
+import { BaseError } from "@webiny/feature/api";
+class LanguageNotFoundError extends BaseError {
+    constructor(languageCode){
+        super({
+            message: `Language not found: "${languageCode}".`,
+            data: {
+                code: languageCode
+            }
+        }), this.code = "Languages/NotFound";
+    }
+}
+class DefaultLanguageNotFoundError extends BaseError {
+    constructor(){
+        super({
+            message: "No default language is configured."
+        }), this.code = "Languages/DefaultNotFound";
+    }
+}
+class LanguagePersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message
+        }), this.code = "Languages/PersistenceError";
+    }
+}
+export { DefaultLanguageNotFoundError, LanguageNotFoundError, LanguagePersistenceError };
+
+//# sourceMappingURL=errors.js.map

package/api/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/errors.js","sources":["../../../src/api/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class LanguageNotFoundError extends BaseError<{ code: string }> {\n    override readonly code = \"Languages/NotFound\" as const;\n\n    constructor(languageCode: string) {\n        super({\n            message: `Language not found: \"${languageCode}\".`,\n            data: {\n                code: languageCode\n            }\n        });\n    }\n}\n\nexport class DefaultLanguageNotFoundError extends BaseError {\n    override readonly code = \"Languages/DefaultNotFound\" as const;\n\n    constructor() {\n        super({\n            message: \"No default language is configured.\"\n        });\n    }\n}\n\nexport class LanguagePersistenceError extends BaseError {\n    override readonly code = \"Languages/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message });\n    }\n}\n"],"names":["LanguageNotFoundError","BaseError","languageCode","DefaultLanguageNotFoundError","LanguagePersistenceError","error"],"mappings":";AAEO,MAAMA,8BAA8BC;IAGvC,YAAYC,YAAoB,CAAE;QAC9B,KAAK,CAAC;YACF,SAAS,CAAC,qBAAqB,EAAEA,aAAa,EAAE,CAAC;YACjD,MAAM;gBACF,MAAMA;YACV;QACJ,SARc,IAAI,GAAG;IASzB;AACJ;AAEO,MAAMC,qCAAqCF;IAG9C,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMG,iCAAiCH;IAG1C,YAAYI,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;QAAC,SAHjB,IAAI,GAAG;IAIzB;AACJ"}

package/api/domain/permissionsSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const LANGUAGES_PERMISSIONS_SCHEMA: {
+    readonly prefix: "languages";
+    readonly fullAccess: true;
+    readonly readOnlyAccess: true;
+};

package/api/domain/permissionsSchema.js

@@ -0,0 +1,9 @@
+import { createPermissionSchema } from "@webiny/api-core/exports/api/security.js";
+const LANGUAGES_PERMISSIONS_SCHEMA = createPermissionSchema({
+    prefix: "languages",
+    fullAccess: true,
+    readOnlyAccess: true
+});
+export { LANGUAGES_PERMISSIONS_SCHEMA };
+
+//# sourceMappingURL=permissionsSchema.js.map

package/api/domain/permissionsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/permissionsSchema.js","sources":["../../../src/api/domain/permissionsSchema.ts"],"sourcesContent":["import { createPermissionSchema } from \"@webiny/api-core/exports/api/security.js\";\n\nexport const LANGUAGES_PERMISSIONS_SCHEMA = createPermissionSchema({\n    prefix: \"languages\",\n    fullAccess: true,\n    readOnlyAccess: true\n});\n"],"names":["LANGUAGES_PERMISSIONS_SCHEMA","createPermissionSchema"],"mappings":";AAEO,MAAMA,+BAA+BC,uBAAuB;IAC/D,QAAQ;IACR,YAAY;IACZ,gBAAgB;AACpB"}

package/api/features/AddCmsPermissions/AddCmsPermissions.d.ts

@@ -0,0 +1,8 @@
+import { PermissionTransformer } from "@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js";
+declare class AddCmsPermissions implements PermissionTransformer.Interface {
+    execute(permission: PermissionTransformer.Permission): PermissionTransformer.Permission[] | PermissionTransformer.Permission;
+}
+declare const _default: typeof AddCmsPermissions & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js").IPermissionTransformer>;
+};
+export default _default;

package/api/features/AddCmsPermissions/AddCmsPermissions.js

@@ -0,0 +1,49 @@
+import { PermissionTransformer } from "@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js";
+import { LANGUAGE_MODEL_ID } from "../../../shared/constants.js";
+class AddCmsPermissions {
+    execute(permission) {
+        if (!permission.name.startsWith("languages.")) return permission;
+        const isReadOnly = "languages.*" === permission.name && "r" === permission.rwd;
+        return [
+            permission,
+            {
+                name: "cms.endpoint.manage",
+                _src: "languages"
+            },
+            {
+                name: "cms.contentModel",
+                own: false,
+                rwd: "r",
+                pw: "",
+                models: [
+                    LANGUAGE_MODEL_ID
+                ],
+                _src: "languages"
+            },
+            {
+                name: "cms.contentModelGroup",
+                own: false,
+                rwd: "r",
+                pw: "",
+                groups: [
+                    "hidden"
+                ],
+                _src: "languages"
+            },
+            {
+                name: "cms.contentEntry",
+                own: false,
+                rwd: isReadOnly ? "r" : "rwd",
+                pw: "",
+                _src: "languages"
+            }
+        ];
+    }
+}
+const AddCmsPermissions_AddCmsPermissions = PermissionTransformer.createImplementation({
+    implementation: AddCmsPermissions,
+    dependencies: []
+});
+export default AddCmsPermissions_AddCmsPermissions;
+
+//# sourceMappingURL=AddCmsPermissions.js.map

package/api/features/AddCmsPermissions/AddCmsPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AddCmsPermissions/AddCmsPermissions.js","sources":["../../../../src/api/features/AddCmsPermissions/AddCmsPermissions.ts"],"sourcesContent":["import { PermissionTransformer } from \"@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js\";\nimport { LANGUAGE_MODEL_ID } from \"~/shared/constants.js\";\n\nclass AddCmsPermissions implements PermissionTransformer.Interface {\n    execute(permission: PermissionTransformer.Permission) {\n        if (!permission.name.startsWith(\"languages.\")) {\n            return permission;\n        }\n\n        const isReadOnly = permission.name === \"languages.*\" && permission.rwd === \"r\";\n\n        return [\n            permission,\n            {\n                name: \"cms.endpoint.manage\",\n                _src: \"languages\"\n            },\n            {\n                name: \"cms.contentModel\",\n                own: false,\n                rwd: \"r\",\n                pw: \"\",\n                models: [LANGUAGE_MODEL_ID],\n                _src: \"languages\"\n            },\n            {\n                name: \"cms.contentModelGroup\",\n                own: false,\n                rwd: \"r\",\n                pw: \"\",\n                groups: [\"hidden\"],\n                _src: \"languages\"\n            },\n            {\n                name: \"cms.contentEntry\",\n                own: false,\n                rwd: isReadOnly ? \"r\" : \"rwd\",\n                pw: \"\",\n                _src: \"languages\"\n            }\n        ];\n    }\n}\n\nexport default PermissionTransformer.createImplementation({\n    implementation: AddCmsPermissions,\n    dependencies: []\n});\n"],"names":["AddCmsPermissions","permission","isReadOnly","LANGUAGE_MODEL_ID","PermissionTransformer"],"mappings":";;AAGA,MAAMA;IACF,QAAQC,UAA4C,EAAE;QAClD,IAAI,CAACA,WAAW,IAAI,CAAC,UAAU,CAAC,eAC5B,OAAOA;QAGX,MAAMC,aAAaD,AAAoB,kBAApBA,WAAW,IAAI,IAAsBA,AAAmB,QAAnBA,WAAW,GAAG;QAEtE,OAAO;YACHA;YACA;gBACI,MAAM;gBACN,MAAM;YACV;YACA;gBACI,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,IAAI;gBACJ,QAAQ;oBAACE;iBAAkB;gBAC3B,MAAM;YACV;YACA;gBACI,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,IAAI;gBACJ,QAAQ;oBAAC;iBAAS;gBAClB,MAAM;YACV;YACA;gBACI,MAAM;gBACN,KAAK;gBACL,KAAKD,aAAa,MAAM;gBACxB,IAAI;gBACJ,MAAM;YACV;SACH;IACL;AACJ;AAEA,4CAAeE,sBAAsB,oBAAoB,CAAC;IACtD,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}

package/api/features/AddCmsPermissions/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const AddCmsPermissionsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/AddCmsPermissions/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import AddCmsPermissions from "./AddCmsPermissions.js";
+const AddCmsPermissionsFeature = createFeature({
+    name: "Languages/AddCmsPermissions",
+    register (container) {
+        container.register(AddCmsPermissions);
+    }
+});
+export { AddCmsPermissionsFeature };
+
+//# sourceMappingURL=feature.js.map

package/api/features/AddCmsPermissions/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AddCmsPermissions/feature.js","sources":["../../../../src/api/features/AddCmsPermissions/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport AddCmsPermissions from \"./AddCmsPermissions.js\";\n\nexport const AddCmsPermissionsFeature = createFeature({\n    name: \"Languages/AddCmsPermissions\",\n    register(container) {\n        container.register(AddCmsPermissions);\n    }\n});\n"],"names":["AddCmsPermissionsFeature","createFeature","container","AddCmsPermissions"],"mappings":";;AAGO,MAAMA,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/api/features/EnsureSingleDefaultLanguage/UnsetDefaultLanguagesHandler.d.ts

@@ -0,0 +1,15 @@
+import { EntryAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/events.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+import { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/abstractions.js";
+declare class UnsetDefaultLanguagesHandler implements EntryAfterUpdateEventHandler.Interface {
+    private getModel;
+    private listLatestEntries;
+    private updateEntry;
+    constructor(getModel: GetModelUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, updateEntry: UpdateEntryRepository.Interface);
+    handle(event: EntryAfterUpdateEventHandler.Event): Promise<void>;
+}
+declare const _default: typeof UnsetDefaultLanguagesHandler & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/UpdateEntry/events.js").EntryAfterUpdateEvent>>;
+};
+export default _default;

package/api/features/EnsureSingleDefaultLanguage/UnsetDefaultLanguagesHandler.js

@@ -0,0 +1,48 @@
+import { EntryAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/events.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+import { LANGUAGE_MODEL_ID } from "../../../shared/constants.js";
+import { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/abstractions.js";
+class UnsetDefaultLanguagesHandler {
+    constructor(getModel, listLatestEntries, updateEntry){
+        this.getModel = getModel;
+        this.listLatestEntries = listLatestEntries;
+        this.updateEntry = updateEntry;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.modelId !== LANGUAGE_MODEL_ID) return;
+        if (!entry.values.isDefault) return;
+        const modelResult = await this.getModel.execute(LANGUAGE_MODEL_ID);
+        if (modelResult.isFail()) return;
+        const languageModel = modelResult.value;
+        const listResult = await this.listLatestEntries.execute(languageModel, {
+            where: {
+                entryId_not: entry.entryId,
+                values: {
+                    isDefault: true
+                }
+            }
+        });
+        if (listResult.isFail()) return;
+        const { entries } = listResult.value;
+        for (const other of entries)await this.updateEntry.execute(languageModel, {
+            ...other,
+            values: {
+                ...other.values,
+                isDefault: false
+            }
+        });
+    }
+}
+const EnsureSingleDefaultLanguage_UnsetDefaultLanguagesHandler = EntryAfterUpdateEventHandler.createImplementation({
+    implementation: UnsetDefaultLanguagesHandler,
+    dependencies: [
+        GetModelUseCase,
+        ListLatestEntriesUseCase,
+        UpdateEntryRepository
+    ]
+});
+export default EnsureSingleDefaultLanguage_UnsetDefaultLanguagesHandler;
+
+//# sourceMappingURL=UnsetDefaultLanguagesHandler.js.map

package/api/features/EnsureSingleDefaultLanguage/UnsetDefaultLanguagesHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/EnsureSingleDefaultLanguage/UnsetDefaultLanguagesHandler.js","sources":["../../../../src/api/features/EnsureSingleDefaultLanguage/UnsetDefaultLanguagesHandler.ts"],"sourcesContent":["import { EntryAfterUpdateEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/events.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js\";\nimport { LANGUAGE_MODEL_ID } from \"~/shared/constants.js\";\nimport { UpdateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/abstractions.js\";\n\nclass UnsetDefaultLanguagesHandler implements EntryAfterUpdateEventHandler.Interface {\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private updateEntry: UpdateEntryRepository.Interface\n    ) {}\n\n    async handle(event: EntryAfterUpdateEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        if (model.modelId !== LANGUAGE_MODEL_ID) {\n            return;\n        }\n\n        if (!entry.values.isDefault) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(LANGUAGE_MODEL_ID);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const languageModel = modelResult.value;\n\n        const listResult = await this.listLatestEntries.execute(languageModel, {\n            where: {\n                entryId_not: entry.entryId,\n                values: {\n                    isDefault: true\n                }\n            }\n        });\n\n        if (listResult.isFail()) {\n            return;\n        }\n\n        const { entries } = listResult.value;\n\n        for (const other of entries) {\n            await this.updateEntry.execute(languageModel, {\n                ...other,\n                values: {\n                    ...other.values,\n                    isDefault: false\n                }\n            });\n        }\n    }\n}\n\nexport default EntryAfterUpdateEventHandler.createImplementation({\n    implementation: UnsetDefaultLanguagesHandler,\n    dependencies: [GetModelUseCase, ListLatestEntriesUseCase, UpdateEntryRepository]\n});\n"],"names":["UnsetDefaultLanguagesHandler","getModel","listLatestEntries","updateEntry","event","entry","model","LANGUAGE_MODEL_ID","modelResult","languageModel","listResult","entries","other","EntryAfterUpdateEventHandler","GetModelUseCase","ListLatestEntriesUseCase","UpdateEntryRepository"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,QAAmC,EACnCC,iBAAqD,EACrDC,WAA4C,CACtD;aAHUF,QAAQ,GAARA;aACAC,iBAAiB,GAAjBA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAEtC,IAAIE,MAAM,OAAO,KAAKC,mBAClB;QAGJ,IAAI,CAACF,MAAM,MAAM,CAAC,SAAS,EACvB;QAGJ,MAAMG,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACD;QAChD,IAAIC,YAAY,MAAM,IAClB;QAGJ,MAAMC,gBAAgBD,YAAY,KAAK;QAEvC,MAAME,aAAa,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACD,eAAe;YACnE,OAAO;gBACH,aAAaJ,MAAM,OAAO;gBAC1B,QAAQ;oBACJ,WAAW;gBACf;YACJ;QACJ;QAEA,IAAIK,WAAW,MAAM,IACjB;QAGJ,MAAM,EAAEC,OAAO,EAAE,GAAGD,WAAW,KAAK;QAEpC,KAAK,MAAME,SAASD,QAChB,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACF,eAAe;YAC1C,GAAGG,KAAK;YACR,QAAQ;gBACJ,GAAGA,MAAM,MAAM;gBACf,WAAW;YACf;QACJ;IAER;AACJ;AAEA,iEAAeC,6BAA6B,oBAAoB,CAAC;IAC7D,gBAAgBb;IAChB,cAAc;QAACc;QAAiBC;QAA0BC;KAAsB;AACpF"}

package/api/features/EnsureSingleDefaultLanguage/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const EnsureSingleDefaultLanguageFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/EnsureSingleDefaultLanguage/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import UnsetDefaultLanguagesHandler from "./UnsetDefaultLanguagesHandler.js";
+const EnsureSingleDefaultLanguageFeature = createFeature({
+    name: "Languages/EnsureSingleDefaultLanguage",
+    register (container) {
+        container.register(UnsetDefaultLanguagesHandler);
+    }
+});
+export { EnsureSingleDefaultLanguageFeature };
+
+//# sourceMappingURL=feature.js.map

package/api/features/EnsureSingleDefaultLanguage/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/EnsureSingleDefaultLanguage/feature.js","sources":["../../../../src/api/features/EnsureSingleDefaultLanguage/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport UnsetDefaultLanguagesHandler from \"./UnsetDefaultLanguagesHandler.js\";\n\nexport const EnsureSingleDefaultLanguageFeature = createFeature({\n    name: \"Languages/EnsureSingleDefaultLanguage\",\n    register(container) {\n        container.register(UnsetDefaultLanguagesHandler);\n    }\n});\n"],"names":["EnsureSingleDefaultLanguageFeature","createFeature","container","UnsetDefaultLanguagesHandler"],"mappings":";;AAGO,MAAMA,qCAAqCC,cAAc;IAC5D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/api/features/GetDefaultLanguage/GetDefaultLanguageRepository.d.ts

@@ -0,0 +1,13 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+import { GetDefaultLanguageRepository as RepositoryAbstraction } from "./abstractions.js";
+declare class GetDefaultLanguageRepositoryImpl implements RepositoryAbstraction.Interface {
+    private getModel;
+    private listLatestEntries;
+    constructor(getModel: GetModelUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface);
+    execute(): RepositoryAbstraction.Return;
+}
+export declare const GetDefaultLanguageRepository: typeof GetDefaultLanguageRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetDefaultLanguageRepository>;
+};
+export {};

package/api/features/GetDefaultLanguage/GetDefaultLanguageRepository.js

@@ -0,0 +1,48 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+import { GetDefaultLanguageRepository } from "./abstractions.js";
+import { LANGUAGE_MODEL_ID } from "../../../shared/constants.js";
+import { DefaultLanguageNotFoundError, LanguagePersistenceError } from "../../domain/errors.js";
+class GetDefaultLanguageRepositoryImpl {
+    constructor(getModel, listLatestEntries){
+        this.getModel = getModel;
+        this.listLatestEntries = listLatestEntries;
+    }
+    async execute() {
+        const modelResult = await this.getModel.execute(LANGUAGE_MODEL_ID);
+        if (modelResult.isFail()) return Result.fail(new LanguagePersistenceError(modelResult.error));
+        const model = modelResult.value;
+        const listResult = await this.listLatestEntries.execute(model, {
+            where: {
+                values: {
+                    isDefault: true
+                }
+            },
+            limit: 1
+        });
+        if (listResult.isFail()) return Result.fail(new LanguagePersistenceError(listResult.error));
+        const { entries } = listResult.value;
+        if (0 === entries.length) return Result.fail(new DefaultLanguageNotFoundError());
+        const entry = entries[0];
+        const language = {
+            id: entry.entryId,
+            name: entry.values.name,
+            code: entry.values.code,
+            direction: entry.values.direction,
+            isDefault: entry.values.isDefault,
+            enabled: entry.values.enabled
+        };
+        return Result.ok(language);
+    }
+}
+const GetDefaultLanguageRepository_GetDefaultLanguageRepository = GetDefaultLanguageRepository.createImplementation({
+    implementation: GetDefaultLanguageRepositoryImpl,
+    dependencies: [
+        GetModelUseCase,
+        ListLatestEntriesUseCase
+    ]
+});
+export { GetDefaultLanguageRepository_GetDefaultLanguageRepository as GetDefaultLanguageRepository };
+
+//# sourceMappingURL=GetDefaultLanguageRepository.js.map

package/api/features/GetDefaultLanguage/GetDefaultLanguageRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetDefaultLanguage/GetDefaultLanguageRepository.js","sources":["../../../../src/api/features/GetDefaultLanguage/GetDefaultLanguageRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js\";\nimport { GetDefaultLanguageRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { LANGUAGE_MODEL_ID } from \"~/shared/constants.js\";\nimport { DefaultLanguageNotFoundError, LanguagePersistenceError } from \"~/api/domain/errors.js\";\nimport type { Language } from \"~/api/domain/Language.js\";\n\nclass GetDefaultLanguageRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface\n    ) {}\n\n    async execute(): RepositoryAbstraction.Return {\n        const modelResult = await this.getModel.execute(LANGUAGE_MODEL_ID);\n        if (modelResult.isFail()) {\n            return Result.fail(new LanguagePersistenceError(modelResult.error));\n        }\n\n        const model = modelResult.value;\n\n        const listResult = await this.listLatestEntries.execute(model, {\n            where: {\n                values: {\n                    isDefault: true\n                }\n            },\n            limit: 1\n        });\n\n        if (listResult.isFail()) {\n            return Result.fail(new LanguagePersistenceError(listResult.error));\n        }\n\n        const { entries } = listResult.value;\n\n        if (entries.length === 0) {\n            return Result.fail(new DefaultLanguageNotFoundError());\n        }\n\n        const entry = entries[0];\n\n        const language: Language = {\n            id: entry.entryId,\n            name: entry.values.name,\n            code: entry.values.code,\n            direction: entry.values.direction,\n            isDefault: entry.values.isDefault,\n            enabled: entry.values.enabled\n        };\n\n        return Result.ok(language);\n    }\n}\n\nexport const GetDefaultLanguageRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetDefaultLanguageRepositoryImpl,\n    dependencies: [GetModelUseCase, ListLatestEntriesUseCase]\n});\n"],"names":["GetDefaultLanguageRepositoryImpl","getModel","listLatestEntries","modelResult","LANGUAGE_MODEL_ID","Result","LanguagePersistenceError","model","listResult","entries","DefaultLanguageNotFoundError","entry","language","GetDefaultLanguageRepository","RepositoryAbstraction","GetModelUseCase","ListLatestEntriesUseCase"],"mappings":";;;;;;AAQA,MAAMA;IACF,YACYC,QAAmC,EACnCC,iBAAqD,CAC/D;aAFUD,QAAQ,GAARA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAM,UAAwC;QAC1C,MAAMC,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAChD,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CAAC,IAAIC,yBAAyBH,YAAY,KAAK;QAGrE,MAAMI,QAAQJ,YAAY,KAAK;QAE/B,MAAMK,aAAa,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACD,OAAO;YAC3D,OAAO;gBACH,QAAQ;oBACJ,WAAW;gBACf;YACJ;YACA,OAAO;QACX;QAEA,IAAIC,WAAW,MAAM,IACjB,OAAOH,OAAO,IAAI,CAAC,IAAIC,yBAAyBE,WAAW,KAAK;QAGpE,MAAM,EAAEC,OAAO,EAAE,GAAGD,WAAW,KAAK;QAEpC,IAAIC,AAAmB,MAAnBA,QAAQ,MAAM,EACd,OAAOJ,OAAO,IAAI,CAAC,IAAIK;QAG3B,MAAMC,QAAQF,OAAO,CAAC,EAAE;QAExB,MAAMG,WAAqB;YACvB,IAAID,MAAM,OAAO;YACjB,MAAMA,MAAM,MAAM,CAAC,IAAI;YACvB,MAAMA,MAAM,MAAM,CAAC,IAAI;YACvB,WAAWA,MAAM,MAAM,CAAC,SAAS;YACjC,WAAWA,MAAM,MAAM,CAAC,SAAS;YACjC,SAASA,MAAM,MAAM,CAAC,OAAO;QACjC;QAEA,OAAON,OAAO,EAAE,CAACO;IACrB;AACJ;AAEO,MAAMC,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBd;IAChB,cAAc;QAACe;QAAiBC;KAAyB;AAC7D"}

package/api/features/GetDefaultLanguage/GetDefaultLanguageUseCase.d.ts

@@ -0,0 +1,8 @@
+import { GetDefaultLanguageUseCase as UseCaseAbstraction, GetDefaultLanguageRepository } from "./abstractions.js";
+declare class GetDefaultLanguageUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetDefaultLanguageRepository.Interface);
+    execute(): UseCaseAbstraction.Return;
+}
+export declare const GetDefaultLanguageUseCase: import("@webiny/di").Implementation<typeof GetDefaultLanguageUseCaseImpl>;
+export {};

package/api/features/GetDefaultLanguage/GetDefaultLanguageUseCase.js

@@ -0,0 +1,20 @@
+import { createImplementation } from "@webiny/feature/api";
+import { GetDefaultLanguageRepository, GetDefaultLanguageUseCase } from "./abstractions.js";
+class GetDefaultLanguageUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute() {
+        return this.repository.execute();
+    }
+}
+const GetDefaultLanguageUseCase_GetDefaultLanguageUseCase = createImplementation({
+    abstraction: GetDefaultLanguageUseCase,
+    implementation: GetDefaultLanguageUseCaseImpl,
+    dependencies: [
+        GetDefaultLanguageRepository
+    ]
+});
+export { GetDefaultLanguageUseCase_GetDefaultLanguageUseCase as GetDefaultLanguageUseCase };
+
+//# sourceMappingURL=GetDefaultLanguageUseCase.js.map