@opengis/fastify-table 2.5.43 → 2.5.46

package/dist/server/routes/crud/functions/readTableRelations.d.ts

@@ -0,0 +1,25 @@
+export default function readTableRelations({ table: paramsTable, id, relname, relationId, uid, userType, referer, limit, page, called, }: {
+    table: string;
+    id: string;
+    relname: string;
+    relationId?: string;
+    uid: string;
+    userType?: string;
+    referer?: string;
+    limit?: number;
+    page?: number;
+    called?: boolean;
+}, pg?: any): Promise<{
+    count: any;
+    filtered: any;
+    total: any;
+    limit: number;
+    page: number;
+    rows: any;
+    schema: any;
+} | {
+    id: string;
+    data: any;
+    schema: any;
+}>;
+//# sourceMappingURL=readTableRelations.d.ts.map

package/dist/server/routes/crud/functions/readTableRelations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readTableRelations.d.ts","sourceRoot":"","sources":["../../../../../server/routes/crud/functions/readTableRelations.ts"],"names":[],"mappings":"AAcA,wBAA8B,kBAAkB,CAC9C,EACE,KAAK,EAAE,WAAW,EAClB,EAAE,EACF,OAAO,EACP,UAAU,EACV,GAAG,EACH,QAAQ,EACR,OAAO,EACP,KAAU,EACV,IAAQ,EACR,MAAc,GACf,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,EACD,EAAE,MAAmB;;;;;;;;;;;;GAkGtB"}

package/dist/server/routes/crud/functions/readTableRelations.js

@@ -0,0 +1,76 @@
+// import config from "../../../../config.js";
+import pgClients from "../../../plugins/pg/pgClients.js";
+import getAccess from "../../../plugins/crud/funcs/getAccess.js";
+import getTemplate from "../../../plugins/table/funcs/getTemplate.js";
+import getData from "../../../plugins/table/funcs/getData.js";
+import { resourcesObject } from "../../../plugins/access/funcs/getResources.js";
+import { BadRequestError, ForbiddenError, NotFoundError, } from "../../../../errors.js";
+export default async function readTableRelations({ table: paramsTable, id, relname, relationId, uid, userType, referer, limit = 10, page = 1, called = false, }, pg = pgClients.client) {
+    if (!paramsTable) {
+        throw BadRequestError("not enough params: table  ");
+    }
+    const resource = resourcesObject[paramsTable]?.table
+        ? paramsTable
+        : undefined;
+    const templateName = resourcesObject[paramsTable]?.table || paramsTable;
+    const loadTable = await getTemplate("table", templateName);
+    if (!loadTable && !(pg.pk?.[templateName] && called)) {
+        throw NotFoundError("table not found");
+    }
+    const { relations = {} } = loadTable || {};
+    if (!relations[relname]) {
+        throw NotFoundError("table relation not found");
+    }
+    const { table: relationTable, form: relationForm, 
+    // localKey = relations[relname]?.localKey,
+    foreignKey = relations[relname]?.foreignKey, } = relations[relname]?.resource
+        ? resourcesObject[relations[relname].resource]
+        : relations[relname];
+    if (!foreignKey) {
+        throw new Error("invalid relation: foreignKey not set");
+    }
+    // check if user has permission to modify main object/row
+    const { actions = [], message: accessMessage } = (await getAccess({
+        resource,
+        table: templateName,
+        form: loadTable?.form,
+        id,
+        user: { uid, user_type: userType },
+        method: "GET",
+    }, pg)) || {};
+    if (accessMessage) {
+        throw ForbiddenError(accessMessage);
+    }
+    if (!actions.includes("edit") && !called) {
+        throw ForbiddenError("access restricted: actions");
+    }
+    const relationTableTemplate = await getTemplate("table", relationTable);
+    const formData = await getTemplate("form", relationTableTemplate?.form || relationForm);
+    const schema = formData?.schema || formData || {};
+    const { count, filtered, total, rows } = await getData({
+        table: relationTable,
+        id: relationId,
+        page: relationId ? undefined : page,
+        limit: relationId ? undefined : limit,
+        uid,
+        userType,
+        referer,
+        columns: Object.keys(schema).concat([foreignKey]),
+        contextQuery: `${foreignKey}=$1`,
+        args: [id],
+        called: true,
+    }, pg);
+    if (relationId) {
+        return { id: relationId, data: rows[0], schema };
+    }
+    const data = {
+        count,
+        filtered,
+        total,
+        limit,
+        page,
+        rows,
+        schema,
+    };
+    return data;
+}

package/dist/server/routes/crud/functions/updateTableRelation.d.ts

@@ -0,0 +1,14 @@
+export default function updateTableRelation({ table: paramsTable, id: paramsId, form: paramsForm, relname, relationId, body, uid, userType, referer, ignoreCheck, called, }: {
+    table: string;
+    id: string;
+    form?: string;
+    relname: string;
+    relationId: string;
+    body: Record<string, any>;
+    uid?: string;
+    userType?: string;
+    referer?: string;
+    ignoreCheck?: boolean;
+    called?: boolean;
+}, pg?: any): Promise<any>;
+//# sourceMappingURL=updateTableRelation.d.ts.map

package/dist/server/routes/crud/functions/updateTableRelation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateTableRelation.d.ts","sourceRoot":"","sources":["../../../../../server/routes/crud/functions/updateTableRelation.ts"],"names":[],"mappings":"AAqBA,wBAA8B,mBAAmB,CAC/C,EACE,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,UAAU,EAChB,OAAO,EACP,UAAU,EACV,IAAI,EACJ,GAAG,EACH,QAAQ,EACR,OAAO,EACP,WAAmB,EACnB,MAAc,GACf,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,EACD,EAAE,MAAmB,gBA+JtB"}

package/dist/server/routes/crud/functions/updateTableRelation.js

@@ -0,0 +1,117 @@
+// import config from "../../../../config.js";
+import pgClients from "../../../plugins/pg/pgClients.js";
+import getTemplate from "../../../plugins/table/funcs/getTemplate.js";
+import dataUpdate from "../../../plugins/crud/funcs/dataUpdate.js";
+import getAccess from "../../../plugins/crud/funcs/getAccess.js";
+import checkXSS from "../../../plugins/policy/funcs/checkXSS.js";
+import validateData from "../../../plugins/crud/funcs/validateData.js";
+import logger from "../../../plugins/logger/getLogger.js";
+import { resourcesObject } from "../../../plugins/access/funcs/getResources.js";
+import { BadRequestError, ConflictError, ForbiddenError, NotFoundError, UnauthorizedError, } from "../../../../errors.js";
+export default async function updateTableRelation({ table: paramsTable, id: paramsId, form: paramsForm, relname, relationId, body, uid, userType, referer, ignoreCheck = false, called = false, }, pg = pgClients.client) {
+    if (!uid) {
+        throw UnauthorizedError("unauthorized");
+    }
+    if (!relationId) {
+        throw BadRequestError("not enough params: relationId");
+    }
+    const resource = resourcesObject[paramsTable] ? paramsTable : undefined;
+    const mainTable = resourcesObject[paramsTable]?.table || paramsTable;
+    const id = paramsId;
+    const { actions = [], message: accessMessage } = (await getAccess({
+        resource,
+        table: mainTable,
+        form: resourcesObject[paramsTable]?.form || paramsForm,
+        id: paramsId,
+        user: { uid, user_type: userType },
+        method: "PUT",
+    }, pg)) || {};
+    if (accessMessage && !called) {
+        throw ForbiddenError(accessMessage);
+    }
+    if (!actions.includes("edit") && !called) {
+        throw ForbiddenError("access restricted: actions");
+    }
+    const loadTemplate = await getTemplate("table", mainTable);
+    if (!loadTemplate) {
+        throw NotFoundError(`table not found: ${mainTable}`);
+    }
+    const { relations = {} } = loadTemplate || {};
+    if (!relations[relname]) {
+        throw NotFoundError(`table relation not found: ${relname}`);
+    }
+    const { table: relationTable, form: relationForm, 
+    // localKey = relations[relname]?.localKey,
+    foreignKey = relations[relname]?.foreignKey, } = relations[relname]?.resource
+        ? resourcesObject[relations[relname].resource]
+        : relations[relname];
+    if (!foreignKey) {
+        throw new Error("invalid relation: foreignKey not set");
+    }
+    const pks = await pg
+        .query(`
+    SELECT
+      connamespace::regnamespace::text,
+      conrelid::regclass,
+      (
+        SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid AND attnum = c.conkey[1]
+      ) as pk
+    FROM pg_constraint c
+    WHERE contype = 'p'
+    AND connamespace::regnamespace::text NOT IN ('sde')`)
+        .then((r) => r.rows || []);
+    const pkList = pks.reduce((acc, curr) => ({
+        ...acc,
+        [curr.connamespace === "public"
+            ? `${curr.connamespace}.${curr.conrelid}`
+            : curr.conrelid]: curr.pk,
+    }), {});
+    const relationTableTemplate = await getTemplate("table", relationTable);
+    const relationPk = pkList[relationTableTemplate?.table || relationTable];
+    if (!relationPk) {
+        throw NotFoundError("invalid relation: primary key column not found");
+    }
+    const existsAndRelated = await pg
+        .query(`select 1 from ${relationTableTemplate?.table || relationTable} where ${foreignKey}=$1 and ${relationPk}=$2`, [paramsId, relationId])
+        .then((r) => r.rowCount > 0);
+    if (!existsAndRelated) {
+        throw NotFoundError(`relation row not found: ${relationId}`);
+    }
+    const formData = await getTemplate("form", relationTableTemplate?.form || relationForm);
+    const schema = formData?.schema || formData;
+    // skip non-present fields in form schema
+    if (!ignoreCheck) {
+        Object.keys(body || {})
+            .filter((key) => !Object.keys(schema || {}).includes(key))
+            .forEach((key) => delete body[key]);
+    }
+    const xssCheck = checkXSS({ body, schema });
+    if (xssCheck.error && formData?.xssCheck !== false) {
+        logger.file("injection/xss", {
+            msg: xssCheck.error,
+            table: relationTable,
+            form: relationForm,
+            uid,
+        });
+        throw ConflictError("Дані не пройшли валідацію. Приберіть некоректні дані та спробуйте ще раз");
+    }
+    const fieldCheck = validateData({ body, schema, update: true });
+    if (fieldCheck.error) {
+        logger.file("injection/formdata", {
+            table: relationTable,
+            form: relationForm,
+            uid,
+            ...fieldCheck,
+        });
+        throw ConflictError("Дані не пройшли валідацію. Приберіть некоректні дані та спробуйте ще раз");
+    }
+    const res = await dataUpdate({
+        pg,
+        table: relationTableTemplate?.table || relationTable,
+        id: relationId,
+        data: body,
+        uid,
+        referer,
+    });
+    return res;
+}

package/dist/server/routes/dictionaries/dictionaries.route.d.ts

@@ -0,0 +1,2 @@
+export default function route(app: any): void;
+//# sourceMappingURL=dictionaries.route.d.ts.map

package/dist/server/routes/dictionaries/dictionaries.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionaries.route.d.ts","sourceRoot":"","sources":["../../../../server/routes/dictionaries/dictionaries.route.ts"],"names":[],"mappings":"AAoBA,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,GAAG,EAAE,GAAG,QAmJrC"}

package/dist/server/routes/dictionaries/dictionaries.route.js

@@ -0,0 +1,134 @@
+import readDictionaries from "./functions/read.dictionaries.js";
+import createDictionary from "./functions/create.dictionary.js";
+import updateDictionary from "./functions/update.dictionary.js";
+import deleteDictionary from "./functions/delete.dictionary.js";
+import createDictionaryItem from "./functions/create.dictionary.item.js";
+import updateDictionaryItem from "./functions/update.dictionary.item.js";
+import deleteDictionaryItem from "./functions/delete.dictionary.item.js";
+import { dictionaryParamsSchema, createDictionaryBodySchema, createDictionaryItemBodySchema, updateDictionaryBodySchema, updateDictionaryItemBodySchema, } from "./dictionaries.schema.js";
+const tags = ["core", "dictionaries"];
+const packageName = "fastify-table";
+export default function route(app) {
+    app.route({
+        method: "GET",
+        url: "/dictionaries/:code?",
+        config: { tags, package: packageName, policy: "L0" },
+        schema: { params: dictionaryParamsSchema },
+        handler: async ({ params, pg }) => {
+            const result = await readDictionaries({
+                code: params.code,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "GET",
+        url: "/dictionaries/:code/values",
+        config: { tags, package: packageName, policy: "L0" },
+        schema: { params: dictionaryParamsSchema },
+        handler: async ({ params, pg }) => {
+            const result = await readDictionaries({
+                code: params.code,
+                values: true,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "POST",
+        url: "/dictionaries/:id?",
+        config: { tags, package: packageName, policy: "L1" },
+        schema: {
+            params: dictionaryParamsSchema,
+            body: createDictionaryBodySchema,
+        },
+        handler: async ({ params, body, user, pg }) => {
+            const result = await createDictionary({
+                id: params.id,
+                body,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "PUT",
+        url: "/dictionaries/:id",
+        config: { tags, package: packageName, policy: "L1" },
+        schema: {
+            params: dictionaryParamsSchema,
+            body: updateDictionaryBodySchema,
+        },
+        handler: async ({ params, user, body, pg }) => {
+            const result = await updateDictionary({
+                id: params.id,
+                body,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "DELETE",
+        url: "/dictionaries/:id",
+        config: { tags, package: packageName, policy: "L1" },
+        schema: { params: dictionaryParamsSchema },
+        handler: async ({ params, user, pg }) => {
+            const result = await deleteDictionary({
+                id: params.id,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "POST",
+        url: "/dictionaries/:code/values/:id?",
+        config: { tags, package: packageName, policy: "L1" },
+        schema: {
+            params: dictionaryParamsSchema,
+            body: createDictionaryItemBodySchema,
+        },
+        handler: async ({ params, body, user, pg }) => {
+            const result = await createDictionaryItem({
+                id: params.id,
+                code: params.code,
+                body,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "PUT",
+        url: "/dictionaries/:code/values/:id",
+        config: { tags, package: packageName, policy: "L1" },
+        schema: {
+            params: dictionaryParamsSchema,
+            body: updateDictionaryItemBodySchema,
+        },
+        handler: async ({ params, body, user, pg }) => {
+            const result = await updateDictionaryItem({
+                id: params.id,
+                code: params.code,
+                body,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        },
+    });
+    app.route({
+        method: "DELETE",
+        url: "/dictionaries/:code/values/:id",
+        config: { tags, package: packageName, policy: "L1" },
+        schema: { params: dictionaryParamsSchema },
+        handler: async ({ params, user, pg }) => {
+            const result = await deleteDictionaryItem({
+                id: params.id,
+                code: params.code,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        },
+    });
+}

package/dist/server/routes/dictionaries/dictionaries.schema.d.ts

@@ -0,0 +1,190 @@
+declare const _default: null;
+export default _default;
+export declare const dictionaryParamsSchema: {
+    type: string;
+    properties: {
+        code: {
+            type: string;
+            pattern: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+    };
+};
+export declare const createDictionaryBodySchema: {
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        code: {
+            type: string;
+            pattern: string;
+        };
+        name: {
+            type: string;
+            pattern: string;
+        };
+        module: {
+            type: string;
+            pattern: string;
+        };
+        description: {
+            type: string;
+            pattern: string;
+        };
+        editable: {
+            type: string;
+        };
+        values: {
+            type: string;
+            minItems: number;
+            maxItems: number;
+            items: {
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    code: {
+                        type: string;
+                        pattern: string;
+                    };
+                    name: {
+                        type: string;
+                        pattern: string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                    icon: {
+                        type: string;
+                    };
+                    sort: {
+                        type: string;
+                        minimum: number;
+                        default: number;
+                    };
+                    metadata: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const updateDictionaryBodySchema: {
+    type: string;
+    additionalProperties: boolean;
+    properties: {
+        code: {
+            type: string;
+            pattern: string;
+        };
+        name: {
+            type: string;
+            pattern: string;
+        };
+        module: {
+            type: string;
+            pattern: string;
+        };
+        description: {
+            type: string;
+            pattern: string;
+        };
+        editable: {
+            type: string;
+        };
+        values: {
+            type: string;
+            minItems: number;
+            maxItems: number;
+            items: {
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    code: {
+                        type: string;
+                        pattern: string;
+                    };
+                    name: {
+                        type: string;
+                        pattern: string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                    icon: {
+                        type: string;
+                    };
+                    sort: {
+                        type: string;
+                        minimum: number;
+                        default: number;
+                    };
+                    metadata: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        system: {
+            type: string;
+        };
+    };
+};
+export declare const createDictionaryItemBodySchema: {
+    type: string;
+    properties: {
+        code: {
+            type: string;
+            pattern: string;
+        };
+        name: {
+            type: string;
+            pattern: string;
+        };
+        color: {
+            type: string;
+        };
+        icon: {
+            type: string;
+        };
+        sort: {
+            type: string;
+            minimum: number;
+            default: number;
+        };
+        metadata: {
+            type: string;
+        };
+    };
+};
+export declare const updateDictionaryItemBodySchema: {
+    type: string;
+    properties: {
+        code: {
+            type: string;
+            pattern: string;
+        };
+        name: {
+            type: string;
+            pattern: string;
+        };
+        color: {
+            type: string;
+        };
+        icon: {
+            type: string;
+        };
+        sort: {
+            type: string;
+            minimum: number;
+            default: number;
+        };
+        metadata: {
+            type: string;
+        };
+    };
+};
+//# sourceMappingURL=dictionaries.schema.d.ts.map

package/dist/server/routes/dictionaries/dictionaries.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionaries.schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/dictionaries/dictionaries.schema.ts"],"names":[],"mappings":";AAAA,wBAAoB;AA2CpB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;CAMlC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CActC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBtC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;CAG1C,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;CAG1C,CAAC"}

package/dist/server/routes/dictionaries/dictionaries.schema.js

@@ -0,0 +1,86 @@
+export default null;
+const idSchema = {
+    type: "string",
+    pattern: "^([\\d\\w_.-]+)$",
+};
+const codeSchema = {
+    type: "string",
+    pattern: "^([\\d\\w_.-]+)$",
+};
+const nameSchema = {
+    type: "string",
+    pattern: "^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-]+)$",
+};
+const moduleSchema = {
+    type: "string",
+    pattern: "^([\\d\\w_.-]+)$",
+};
+const descriptionSchema = {
+    type: "string",
+    pattern: "^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-]+)$",
+};
+const itemSchema = {
+    code: codeSchema,
+    name: nameSchema,
+    color: { type: "string" },
+    icon: { type: "string" },
+    sort: { type: "integer", minimum: 0, default: 0 },
+    metadata: { type: "object" },
+};
+const valuesSchema = {
+    type: "array",
+    minItems: 2,
+    maxItems: 100,
+    items: {
+        required: ["code", "name", "sort"],
+        additionalProperties: false,
+        properties: itemSchema,
+    },
+};
+export const dictionaryParamsSchema = {
+    type: "object",
+    properties: {
+        code: codeSchema,
+        id: idSchema,
+    },
+};
+export const createDictionaryBodySchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["code", "name"],
+    properties: {
+        code: codeSchema,
+        name: nameSchema,
+        module: moduleSchema,
+        description: descriptionSchema,
+        editable: {
+            type: "boolean",
+        },
+        values: valuesSchema,
+    },
+};
+export const updateDictionaryBodySchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        code: codeSchema,
+        name: nameSchema,
+        module: moduleSchema,
+        description: descriptionSchema,
+        editable: {
+            type: "boolean",
+        },
+        values: valuesSchema,
+        system: {
+            type: "boolean",
+        },
+    },
+};
+export const createDictionaryItemBodySchema = {
+    type: "object",
+    properties: itemSchema,
+};
+export const updateDictionaryItemBodySchema = {
+    type: "object",
+    properties: itemSchema,
+};

package/dist/server/routes/dictionaries/functions/create.dictionary.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {String} id Dictionary ID, optional
+ */
+export default function createDictionary({ id, body, uid, }: {
+    id: string;
+    body: Record<string, any>;
+    uid: string;
+}, pg?: any): Promise<any>;
+//# sourceMappingURL=create.dictionary.d.ts.map

package/dist/server/routes/dictionaries/functions/create.dictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.dictionary.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dictionaries/functions/create.dictionary.ts"],"names":[],"mappings":"AAOA;;;GAGG;AAEH,wBAA8B,gBAAgB,CAC5C,EACE,EAAE,EACF,IAAI,EACJ,GAAG,GACJ,EAAE;IACD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb,EACD,EAAE,MAAmB,gBA8EtB"}