@opengis/fastify-table 2.5.53 → 3.0.0-beta.0

package/dist/server/routes/dblist/controllers/setItem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setItem.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dblist/controllers/setItem.ts"],"names":[],"mappings":"AAKA,wBAA8B,OAAO,CAAC,GAAG,EAAE,GAAG;;GAuB7C"}

package/dist/server/routes/dblist/controllers/setItem.js

@@ -1,21 +0,0 @@
-import { BadRequestError } from "../../../../errors.js";
-import { config, dblist, getRedis } from "../../../../utils.js";
-const rclient = getRedis();
-export default async function setItem(req) {
-    const { params = {} } = req;
-    const { id } = params;
-    if (!id) {
-        throw BadRequestError("not enough params: id");
-    }
-    const current = dblist.find((el) => [el.id, el.key].includes(id));
-    if (!current?.database) {
-        throw BadRequestError("invalid param id");
-    }
-    const uid = req.session?.passport?.user?.uid || // login db
-        req.session?.passport?.user?.username || // login passwd
-        "2";
-    if (config.redis) {
-        await rclient.setex(`current-db:${uid}`, 60 * 60 * 10000, id);
-    }
-    return { current: id };
-}

package/dist/server/routes/dblist/index.d.ts

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

package/dist/server/routes/dblist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/routes/dblist/index.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,GAAG,EAAE,GAAG,QAiBtC"}

package/dist/server/routes/dblist/index.js

@@ -1,24 +0,0 @@
-import readItemList from "./controllers/readItems.js";
-import setItem from "./controllers/setItem.js";
-const packageName = "fastify-table";
-const params = {
-    config: { policy: "L0", tags: ["core", "dblist"], package: packageName },
-};
-export default function plugin(app) {
-    if (!app.hasRoute({ method: "GET", url: "/db-list" })) {
-        app.route({
-            method: "GET",
-            url: "/db-list",
-            ...params,
-            handler: readItemList,
-        });
-    }
-    if (!app.hasRoute({ method: "GET", url: "/db-list/:id" })) {
-        app.route({
-            method: "GET",
-            url: "/db-list/:id",
-            ...params,
-            handler: setItem,
-        });
-    }
-}

package/dist/server/routes/dblist/utils/formatData.d.ts

@@ -1,2 +0,0 @@
-export default function formatData(data?: any[]): any;
-//# sourceMappingURL=formatData.d.ts.map

package/dist/server/routes/dblist/utils/formatData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatData.d.ts","sourceRoot":"","sources":["../../../../../server/routes/dblist/utils/formatData.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,IAAI,GAAE,GAAG,EAAO,GAAG,GAAG,CAQxD"}

package/dist/server/routes/dblist/utils/formatData.js

@@ -1,8 +0,0 @@
-const showKeys = ["id", "key", "title"];
-export default function formatData(data = []) {
-    return data?.length
-        ? data.map((el) => Object.keys(el)
-            .filter((key) => showKeys.includes(key))
-            .reduce((acc, curr) => Object.assign(acc, { [curr]: el[curr] }), {}))
-        : [];
-}

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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,134 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,86 +0,0 @@
-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

@@ -1,10 +0,0 @@
-/**
- *
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-/**
- *
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,57 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,9 +0,0 @@
-/**
- *
- * @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

@@ -1 +0,0 @@
-{"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"}