@opengis/fastify-table 2.5.44 → 2.5.47

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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.dictionary.item.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dictionaries/functions/create.dictionary.item.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH,wBAA8B,oBAAoB,CAChD,EACE,EAAE,EACF,IAAI,EACJ,IAAI,EACJ,GAAG,GACJ,EAAE;IACD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb,EACD,EAAE,MAAmB,gBA2DtB"}

package/dist/server/routes/dictionaries/functions/create.dictionary.item.js

@@ -0,0 +1,57 @@
+import pgClients from "../../../plugins/pg/pgClients.js";
+import dataInsert from "../../../plugins/crud/funcs/dataInsert.js";
+import { BadRequestError, NotFoundError } from "../../../../errors.js";
+import updateDictionary from "./update.dictionary.js";
+/**
+ *
+ * @param {String} id Item ID, optional
+ * @param {String} code Dictionary code (filename)
+ * @param {String} body.code Item code
+ */
+export default async function createDictionaryItem({ id, code, body, uid, }, pg = pgClients.client) {
+    if (!pg) {
+        throw new Error("empty pg");
+    }
+    if (!code) {
+        throw BadRequestError("not enough params: code");
+    }
+    if (!body) {
+        throw BadRequestError("not enough params: body");
+    }
+    if (!body.code) {
+        throw BadRequestError("not enough body params: code");
+    }
+    if (!body.name) {
+        throw BadRequestError("not enough body params: name");
+    }
+    const { system, id: dictionaryId } = await pg
+        .query("select id from admin.dictionaries where code=$1", [code])
+        .then((r) => ({ system: r.rows?.[0]?.system, id: r.rows?.[0]?.id }));
+    if (!dictionaryId) {
+        throw NotFoundError("dictionary not found");
+    }
+    // make custom
+    if (system) {
+        await updateDictionary({ id: dictionaryId, body: { system: false }, uid }, pg);
+    }
+    const { data } = await dataInsert({
+        id,
+        table: "admin.dictionary_items",
+        data: {
+            code: body.code,
+            dictionary_id: dictionaryId,
+            name: body.name,
+            description: body.description,
+            color: body.color,
+            icon: body.icon,
+            parent_id: body.parent_id,
+            sort_order: body.sort,
+            metadata: body.metadata,
+            system: false,
+            active: body.active === false ? false : true,
+        },
+        pg,
+        uid,
+    });
+    return data;
+}

package/dist/server/routes/dictionaries/functions/create.dictionary.js

@@ -0,0 +1,76 @@
+import pgClients from "../../../plugins/pg/pgClients.js";
+import dataInsert from "../../../plugins/crud/funcs/dataInsert.js";
+import deleteDictionary from "./delete.dictionary.js";
+import { BadRequestError } from "../../../../errors.js";
+/**
+ *
+ * @param {String} id Dictionary ID, optional
+ */
+export default async function createDictionary({ id, body, uid, }, pg = pgClients.client) {
+    if (!pg) {
+        throw new Error("empty pg");
+    }
+    if (!body) {
+        throw BadRequestError("not enough params: body");
+    }
+    if (!body?.values?.length) {
+        // throw BadRequestError("not enough body params: values");
+    }
+    const client = await pg.connect();
+    try {
+        const systemDictionaryId = await pg
+            .query("select id from admin.dictionaries where system and id = $1", [id])
+            .then((r) => r.rows?.[0]?.id);
+        await client.query("begin");
+        if (systemDictionaryId) {
+            await deleteDictionary({ id: systemDictionaryId, uid }, client);
+        }
+        const { data } = (await dataInsert({
+            id,
+            table: "admin.dictionaries",
+            data: {
+                code: body.code,
+                name: body.name,
+                module: body.module,
+                description: body.description,
+                source: "custom",
+                system: false,
+                editable: body.editable === false ? false : true,
+            },
+            pg: client,
+            uid,
+        })) || {};
+        if (!data) {
+            throw new Error("dictionary insert error");
+        }
+        const values = await Promise.all((body.values || []).map(async (el) => {
+            return dataInsert({
+                table: "admin.dictionary_items",
+                data: {
+                    dictionary_id: id,
+                    code: el.code,
+                    name: el.name,
+                    description: el.description,
+                    color: el.color,
+                    icon: el.icon,
+                    parent_id: el.parent_id,
+                    sort_order: el.sort_order,
+                    metadata: el.metadata,
+                    system: false,
+                    active: el.active === false ? false : true,
+                },
+                pg: client,
+                uid,
+            }).then((r) => r.data);
+        }));
+        await client.query("commit");
+        return { ...data, values };
+    }
+    catch (err) {
+        await client.query("rollback");
+        throw err;
+    }
+    finally {
+        client.release();
+    }
+}

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

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

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

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

package/dist/server/routes/dictionaries/functions/delete.dictionary.item.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {String} id Item ID
+ * @param {String} code Dictionary code (filename)
+ */
+export default function deleteDictionaryItem({ id, code, uid, }: {
+    id: string;
+    code: string;
+    uid: string;
+}, pg?: any): Promise<any>;
+//# sourceMappingURL=delete.dictionary.item.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.dictionary.item.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dictionaries/functions/delete.dictionary.item.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH,wBAA8B,oBAAoB,CAChD,EACE,EAAE,EACF,IAAI,EACJ,GAAG,GACJ,EAAE;IACD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,EACD,EAAE,MAAmB,gBAiCtB"}

package/dist/server/routes/dictionaries/functions/delete.dictionary.item.js

@@ -0,0 +1,32 @@
+import pgClients from "../../../plugins/pg/pgClients.js";
+import dataDelete from "../../../plugins/crud/funcs/dataDelete.js";
+import { BadRequestError, NotFoundError } from "../../../../errors.js";
+/**
+ *
+ * @param {String} id Item ID
+ * @param {String} code Dictionary code (filename)
+ */
+export default async function deleteDictionaryItem({ id, code, uid, }, pg = pgClients.client) {
+    if (!pg) {
+        throw new Error("empty pg");
+    }
+    if (!id) {
+        throw BadRequestError("not enough params: id");
+    }
+    if (!code) {
+        throw BadRequestError("not enough params: code");
+    }
+    const itemId = await pg
+        .query("select id from admin.dictionary_items where dictionary_id in (select id from admin.dictionaries where $1 in (id,code) ) and $2 in (id,code)", [code, id])
+        .then((r) => r.rows?.[0]?.id);
+    if (!itemId) {
+        throw NotFoundError("dictionary item not found");
+    }
+    const item = await dataDelete({
+        id: itemId,
+        table: "admin.dictionary_items",
+        pg,
+        uid,
+    });
+    return item;
+}

package/dist/server/routes/dictionaries/functions/delete.dictionary.js

@@ -0,0 +1,28 @@
+import pgClients from "../../../plugins/pg/pgClients.js";
+import dataDelete from "../../../plugins/crud/funcs/dataDelete.js";
+import { BadRequestError, NotFoundError } from "../../../../errors.js";
+/**
+ *
+ * @param {String} id Dictionary ID
+ */
+export default async function deleteDictionary({ id, uid, }, pg = pgClients.client) {
+    if (!pg) {
+        throw new Error("empty pg");
+    }
+    if (!id) {
+        throw BadRequestError("not enough params: id");
+    }
+    const values = await pg
+        .query("delete from admin.dictionary_items where dictionary_id=$1 returning id,code,name,color,icon", [id])
+        .then((r) => r.rowCount || 0);
+    const row = await dataDelete({
+        table: "admin.dictionaries",
+        id,
+        uid,
+        pg,
+    });
+    if (!row) {
+        throw NotFoundError("dictionary not found");
+    }
+    return { ...row, values };
+}

package/dist/server/routes/dictionaries/functions/read.dictionaries.d.ts

@@ -0,0 +1,5 @@
+export default function readDictionaries({ code, values, }: {
+    code: string;
+    values?: boolean;
+}, pg?: any): Promise<any>;
+//# sourceMappingURL=read.dictionaries.d.ts.map

package/dist/server/routes/dictionaries/functions/read.dictionaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.dictionaries.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dictionaries/functions/read.dictionaries.ts"],"names":[],"mappings":"AAIA,wBAA8B,gBAAgB,CAC5C,EACE,IAAI,EACJ,MAAc,GACf,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,EACD,EAAE,MAAmB,gBAqCtB"}

package/dist/server/routes/dictionaries/functions/read.dictionaries.js

@@ -0,0 +1,27 @@
+import pgClients from "../../../plugins/pg/pgClients.js";
+import { NotFoundError } from "../../../../errors.js";
+export default async function readDictionaries({ code, values = false, }, pg = pgClients.client) {
+    if (!pg) {
+        throw new Error("empty pg");
+    }
+    if (!code) {
+        const rows = await pg
+            .query("select code,name,module,source from admin.dictionaries")
+            .then((r) => r.rows || []);
+        return { total: rows.length, rows };
+    }
+    // code is unique
+    const rows = await pg
+        .query("select id, code, name, module, description, source, editable, system from admin.dictionaries where $1 in (code, id) limit 1", [code])
+        .then((r) => r.rows || []);
+    if (!rows.length) {
+        throw NotFoundError("dictionary not found");
+    }
+    const items = await pg
+        .query("select code, name, description, color, icon, sort_order as sort, parent_id, active, system, metadata from admin.dictionary_items where dictionary_id=$1", [rows[0].id])
+        .then((r) => r.rows || []);
+    if (values) {
+        return items;
+    }
+    return { ...rows[0], values: items };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"update.dictionary.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dictionaries/functions/update.dictionary.ts"],"names":[],"mappings":"AAIA;;;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,gBAyDtB"}

package/dist/server/routes/dictionaries/functions/update.dictionary.item.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {String} id Item ID
+ * @param {String} code Dictionary code (filename)
+ * @param {String} body.code Item code
+ */
+export default function updateDictionaryItem({ id, code, body, uid, }: {
+    id: string;
+    code: string;
+    body: Record<string, any>;
+    uid: string;
+}, pg?: any): Promise<any>;
+//# sourceMappingURL=update.dictionary.item.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update.dictionary.item.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dictionaries/functions/update.dictionary.item.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH,wBAA8B,oBAAoB,CAChD,EACE,EAAE,EACF,IAAI,EACJ,IAAI,EACJ,GAAG,GACJ,EAAE;IACD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb,EACD,EAAE,MAAmB,gBAiDtB"}

package/dist/server/routes/dictionaries/functions/update.dictionary.item.js

@@ -0,0 +1,48 @@
+import pgClients from "../../../plugins/pg/pgClients.js";
+import dataUpdate from "../../../plugins/crud/funcs/dataUpdate.js";
+import updateDictionary from "./update.dictionary.js";
+import { BadRequestError, NotFoundError } from "../../../../errors.js";
+/**
+ *
+ * @param {String} id Item ID
+ * @param {String} code Dictionary code (filename)
+ * @param {String} body.code Item code
+ */
+export default async function updateDictionaryItem({ id, code, body, uid, }, pg = pgClients.client) {
+    if (!pg) {
+        throw new Error("empty pg");
+    }
+    if (!code) {
+        throw BadRequestError("not enough params: code");
+    }
+    if (!body) {
+        throw BadRequestError("not enough params: body");
+    }
+    const { system, id: dictionaryId } = await pg
+        .query("select id from admin.dictionaries where $1 in (id,code)", [code])
+        .then((r) => ({ system: r.rows?.[0]?.system, id: r.rows?.[0]?.id }));
+    if (!dictionaryId) {
+        throw NotFoundError("dictionary not found");
+    }
+    const itemId = await pg
+        .query("select id from admin.dictionary_items where $1 in (id,code)", [id])
+        .then((r) => r.rows?.[0]?.id);
+    if (!itemId) {
+        throw NotFoundError("dictionary item not found");
+    }
+    // make custom
+    if (system) {
+        await updateDictionary({ id: dictionaryId, body: { system: false }, uid }, pg);
+    }
+    const row = await dataUpdate({
+        id: itemId,
+        table: "admin.dictionary_items",
+        data: {
+            ...body,
+            sort_order: body.sort,
+        },
+        pg,
+        uid,
+    });
+    return row;
+}