@opengis/fastify-table 2.3.5 → 2.4.0

package/dist/server/plugins/upload/s3.js

@@ -138,6 +138,7 @@ export async function refreshUploadTTL(id, ttl = UPLOAD_TTL_SECONDS, s3 = s3Clie
 }
 export async function deleteUploadMeta(id, key) {
     clearUploadTimeout(id);
+    await deleteUploadParts(id);
     if (!config.redis) {
         const meta = uploads.get(id);
         uploads.delete(id);
@@ -295,6 +296,39 @@ export async function startUpload({ Bucket, Key, ContentType, fileSize, }, s3 =
         UploadId: res.UploadId,
     };
 }
+const uploadPartsKey = (id) => `upload:${id}:parts`;
+// non-redis in-memory parts cache
+const uploadParts = new Map();
+export async function savePart(id, part) {
+    if (!config.redis) {
+        const existing = uploadParts.get(id) || [];
+        // overwrite existing part number (S3 semantics)
+        const filtered = existing.filter((p) => p.PartNumber !== part.PartNumber);
+        filtered.push(part);
+        uploadParts.set(id, filtered);
+        return;
+    }
+    // use redis hash keyed by part number
+    await rclient.hset(uploadPartsKey(id), String(part.PartNumber), JSON.stringify(part));
+    // keep ttl aligned with upload meta
+    await rclient.expire(uploadPartsKey(id), REDIS_TTL);
+}
+export async function getStoredParts(id) {
+    if (!config.redis) {
+        return (uploadParts.get(id) || []).sort((a, b) => a.PartNumber - b.PartNumber);
+    }
+    const parts = await rclient.hgetall(uploadPartsKey(id));
+    return Object.values(parts)
+        .map((v) => JSON.parse(v))
+        .sort((a, b) => a.PartNumber - b.PartNumber);
+}
+export async function deleteUploadParts(id) {
+    if (!config.redis) {
+        uploadParts.delete(id);
+        return;
+    }
+    await rclient.del(uploadPartsKey(id));
+}
 export async function uploadChunk({ id, chunk, partNumber, }, s3 = s3Client) {
     if (!s3)
         throw new Error("No S3 client");
@@ -305,13 +339,17 @@ export async function uploadChunk({ id, chunk, partNumber, }, s3 = s3Client) {
     if (upload.parts.some((p) => p.PartNumber === partNumber)) {
         throw new Error(`Part ${partNumber} already uploaded`);
     }
-    await s3.send(new UploadPartCommand({
+    const res = await s3.send(new UploadPartCommand({
         Bucket: upload.Bucket,
         Key: upload.Key,
         UploadId: upload.UploadId,
         PartNumber: partNumber,
         Body: chunk,
     }));
+    await savePart(id, {
+        ETag: res.ETag,
+        PartNumber: partNumber,
+    });
     await refreshUploadTTL(id, UPLOAD_TTL_SECONDS, s3);
     return upload;
 }
@@ -321,25 +359,30 @@ export async function finishUpload({ id, }, s3 = s3Client) {
     const redisCache = await getUploadMeta(id);
     const { fileSize: cachedSize, Key, Bucket } = redisCache || {};
     const size = cachedSize ? Number(cachedSize) : undefined;
-    const upload = await findUpload({ id }, s3);
-    if (!upload?.uploaded) {
-        throw new Error("File not uploaded");
-    }
-    if (size && size !== upload.uploaded) {
-        throw new Error("File size mismatch");
-    }
+    // const upload = await findUpload({ id }, s3);
+    // if (!upload?.uploaded) {
+    //   throw new Error("File not uploaded");
+    // }
+    // if (size && size !== upload.uploaded) {
+    //   throw new Error("File size mismatch");
+    // }
+    const parts = await getStoredParts(id);
     await s3.send(new CompleteMultipartUploadCommand({
         Bucket,
         Key,
         UploadId: id,
         MultipartUpload: {
-            Parts: upload.parts.sort((a, b) => a.PartNumber - b.PartNumber),
+            Parts: parts.sort((a, b) => a.PartNumber - b.PartNumber),
+            // Parts: upload.parts.sort(
+            //   (a: any, b: any) => a.PartNumber - b.PartNumber
+            // ),
         },
     }));
     await deleteUploadMeta(id, Key);
     return {
         finished: true,
-        uploaded: upload.uploaded,
+        // uploaded: upload.uploaded,
+        uploaded: size,
         filepath: Key.replace(config.folder, ""),
     };
 }
@@ -379,6 +422,7 @@ export async function getUploadStatus({ id, Key, Bucket, }, s3 = s3Client) {
             uploaded: res?.ContentLength,
         };
     }
+    // const parts = id ? await getStoredParts(id) : { Parts: [] };
     const parts = await s3
         .send(new ListPartsCommand({
         Bucket: redisBucket,

package/dist/server/plugins/upload/s3minio.d.ts

@@ -0,0 +1,59 @@
+export declare function close(): void;
+export declare function startUpload({ Bucket, Key, fileSize: size, ContentType, }: {
+    Bucket?: string;
+    Key: string;
+    fileSize: number;
+    ContentType: string;
+}): Promise<{
+    UploadId: any;
+}>;
+export declare function findUpload({ Bucket, Key, id: UploadId, }: {
+    Bucket?: string;
+    Key?: string;
+    id?: string;
+}): Promise<{
+    UploadId: string;
+    fileSize: any;
+} | {
+    UploadId: any;
+    fileSize?: undefined;
+}>;
+export declare function uploadChunk({ id: UploadId, chunk: Body, partNumber: PartNumber, }: {
+    id: string;
+    chunk: any;
+    partNumber: number;
+}): Promise<{
+    uploaded: any;
+    ETag: any;
+    PartNumber: number;
+}>;
+export declare function finishUpload({ id: UploadId }: {
+    id: string;
+}): Promise<{
+    finished: boolean;
+    uploaded: any;
+    filepath: any;
+}>;
+export declare function getUploadStatus({ id, Bucket, Key, }: {
+    id?: string;
+    Key?: string;
+    Bucket?: string;
+}): Promise<{
+    exists: boolean;
+    finished: boolean;
+    uploaded: any;
+    id: any;
+    size: number | undefined;
+    parts: {
+        ETag: any;
+        PartNumber: any;
+    }[];
+}>;
+export declare function cleanupMultipartUploads({ Bucket, }?: {
+    Bucket: string;
+}): Promise<PromiseSettledResult<{
+    Key: any;
+    UploadId: any;
+}>[]>;
+export declare function deleteUploadMeta(id: string): Promise<void>;
+//# sourceMappingURL=s3minio.d.ts.map

package/dist/server/plugins/upload/s3minio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3minio.d.ts","sourceRoot":"","sources":["../../../../server/plugins/upload/s3minio.ts"],"names":[],"mappings":"AAuBA,wBAAgB,KAAK,SAIpB;AAwBD,wBAAsB,WAAW,CAAC,EAChC,MAA2C,EAC3C,GAAG,EACH,QAAQ,EAAE,IAAI,EACd,WAAW,GACZ,EAAE;IACD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;;GAqBA;AAED,wBAAsB,UAAU,CAAC,EAC/B,MAA2C,EAC3C,GAAG,EACH,EAAE,EAAE,QAAQ,GACb,EAAE;IACD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;;;;;;GAuBA;AAED,wBAAsB,WAAW,CAAC,EAChC,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,IAAI,EACX,UAAU,EAAE,UAAU,GACvB,EAAE;IACD,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB;;;;GA8BA;AAED,wBAAsB,YAAY,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;;;;GAwClE;AAED,wBAAsB,eAAe,CAAC,EACpC,EAAE,EACF,MAAM,EACN,GAAG,GACJ,EAAE;IACD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;;;;;;;;;;GA4CA;AAED,wBAAsB,uBAAuB,CAC3C,EACE,MAAM,GACP,GAAE;IACD,MAAM,EAAE,MAAM,CAAC;CACiC;;;MAqCnD;AAED,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,iBAEhD"}

package/dist/server/plugins/upload/s3minio.js

@@ -0,0 +1,199 @@
+import http from "node:http";
+import https from "node:https";
+import { Client } from "minio";
+import config from "../../../config.js";
+import rclient from "../../plugins/redis/client.js";
+import { BadRequestError, NotFoundError } from "../../../errors.js";
+const [protocol, endPoint, port] = config.s3?.endpoint?.split?.(":") || [];
+const useSSL = config.s3?.useSSL || protocol === "https";
+const agent = useSSL
+    ? new https.Agent({
+        keepAlive: true,
+        maxSockets: 100,
+    })
+    : new http.Agent({
+        keepAlive: true,
+        maxSockets: 100,
+    });
+export function close() {
+    console.log("closing minio connections");
+    agent.destroy();
+    console.log("closed minio agent");
+}
+const minio = endPoint
+    ? new Client({
+        endPoint: endPoint.substring(2), // trim "//" after split of http://ip:port
+        port: port,
+        useSSL,
+        accessKey: config.s3.user,
+        secretKey: config.s3.password,
+        // transport: agent,
+    })
+    : null;
+if (minio) {
+    minio.setRequestOptions({
+        agent,
+    });
+}
+const UPLOAD_TTL_SECONDS = 60 * 60 * 24;
+const CLEANUP_OLDER_THAN_MS = 1000 * 60 * 60 * 24;
+const uploadCacheKey = (id) => `multipart:upload:${id}`;
+export async function startUpload({ Bucket = config.s3?.containerName || "work", Key, fileSize: size, ContentType, }) {
+    if (!minio)
+        throw new Error("s3 not configured");
+    if (!size)
+        throw new BadRequestError("invalid params: size");
+    if (!Key)
+        throw new BadRequestError("not enough params: Key");
+    if (!ContentType)
+        throw new BadRequestError("not enough params: ContentType");
+    const res = await minio.initiateNewMultipartUpload(Bucket, Key, {
+        "Content-Type": ContentType,
+    });
+    const redisKey = uploadCacheKey(res);
+    await rclient.set(redisKey, JSON.stringify({ Bucket, Key, ContentType, size }), "EX", UPLOAD_TTL_SECONDS);
+    return {
+        UploadId: res,
+    };
+}
+export async function findUpload({ Bucket = config.s3?.containerName || "work", Key, id: UploadId, }) {
+    if (!minio)
+        throw new Error("s3 not configured");
+    if (UploadId) {
+        const redisKey = uploadCacheKey(UploadId);
+        const cache = await rclient
+            .get(redisKey)
+            .then((r) => JSON.parse(r || "{}"));
+        return {
+            UploadId,
+            fileSize: cache.size,
+        };
+    }
+    if (!Key)
+        throw new BadRequestError("not enough params: Key");
+    const uploads = await minio.listIncompleteUploads(Bucket, Key, true);
+    const found = uploads.find((u) => u.key === Key);
+    return {
+        UploadId: found?.uploadId,
+    };
+}
+export async function uploadChunk({ id: UploadId, chunk: Body, partNumber: PartNumber, }) {
+    if (!minio)
+        throw new Error("s3 not configured");
+    const redisKey = uploadCacheKey(UploadId);
+    const cache = await rclient
+        .get(redisKey)
+        .then((r) => JSON.parse(r || "{}"));
+    if (!cache.Key) {
+        throw NotFoundError("multipart upload not found");
+    }
+    const etag = await minio.uploadPart({
+        bucketName: cache.Bucket,
+        objectName: cache.Key,
+        uploadID: UploadId,
+        partNumber: PartNumber,
+        headers: {
+            "Content-Type": cache.contentType,
+        },
+    }, Body);
+    return {
+        uploaded: Body.length,
+        ETag: etag,
+        PartNumber,
+    };
+}
+export async function finishUpload({ id: UploadId }) {
+    if (!minio)
+        throw new Error("s3 not configured");
+    const redisKey = uploadCacheKey(UploadId);
+    const cache = await rclient
+        .get(redisKey)
+        .then((r) => JSON.parse(r || "{}"));
+    if (!cache.Bucket || !cache.Key) {
+        throw NotFoundError("s3 upload not found");
+    }
+    const parts = cache.Bucket && cache.Key
+        ? await minio.listParts(cache.Bucket, cache.Key, UploadId)
+        : [];
+    const uploaded = parts.reduce((acc, curr) => acc + (curr.size || 0), 0) || 0;
+    const sortedParts = parts
+        .map((p) => ({
+        part: p.part,
+        etag: p.etag,
+    }))
+        .sort((a, b) => a.part - b.part);
+    await minio.completeMultipartUpload(cache.Bucket, cache.Key, UploadId, sortedParts);
+    await rclient.del(redisKey);
+    return {
+        finished: true,
+        uploaded,
+        filepath: cache.Key.replace(config.folder, ""),
+    };
+}
+export async function getUploadStatus({ id, Bucket, Key, }) {
+    if (!minio)
+        throw new Error("s3 not configured");
+    if (!id && !(Bucket && Key)) {
+        throw new BadRequestError("not enough params: id / Bucket && Key");
+    }
+    const UploadId = id || (await findUpload({ Bucket, Key }).then((r) => r.UploadId));
+    const cache = UploadId
+        ? await rclient
+            .get(uploadCacheKey(UploadId))
+            .then((r) => JSON.parse(r || "{}"))
+        : {};
+    let stat;
+    let parts = [];
+    const Key1 = id ? cache.Key : Key;
+    const Bucket1 = id ? cache.Bucket : Bucket;
+    if (Bucket1 && Key1 && UploadId) {
+        try {
+            stat = await minio.statObject(Bucket1, Key1);
+        }
+        catch { }
+        try {
+            parts = await minio.listParts(Bucket1, Key1, UploadId);
+        }
+        catch { }
+    }
+    return {
+        exists: !!stat || !!parts.length,
+        finished: !!stat,
+        uploaded: stat
+            ? stat.size
+            : parts.reduce((acc, curr) => acc + (curr.size || 0), 0),
+        id: UploadId,
+        size: cache.size ? Number(cache.size) : undefined,
+        parts: parts.map((p) => ({
+            ETag: p.etag,
+            PartNumber: p.part,
+        })),
+    };
+}
+export async function cleanupMultipartUploads({ Bucket, } = { Bucket: config.s3?.containerName || "work" }) {
+    if (!minio)
+        throw new Error("s3 not configured");
+    console.log("minio cleanupMultipartUploads start");
+    const stream = minio.listIncompleteUploads(Bucket, "", true);
+    const uploads = [];
+    for await (const upload of stream) {
+        uploads.push(upload);
+    }
+    const now = Date.now();
+    const staleUploads = uploads.filter((u) => u.initiated &&
+        now - new Date(u.initiated).getTime() > CLEANUP_OLDER_THAN_MS);
+    const results = await Promise.allSettled(staleUploads.map(async (upload) => {
+        await minio.removeIncompleteUpload(Bucket, upload.key);
+        const redisKey = uploadCacheKey(upload.uploadId);
+        await rclient.del(redisKey);
+        return {
+            Key: upload.key,
+            UploadId: upload.uploadId,
+        };
+    }));
+    return results;
+}
+export async function deleteUploadMeta(id) {
+    if (rclient && id)
+        await rclient.del(id);
+}

package/dist/server/plugins/upload/startUpload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startUpload.d.ts","sourceRoot":"","sources":["../../../../server/plugins/upload/startUpload.ts"],"names":[],"mappings":"AAiBA,wBAA8B,WAAW,CAAC,EACxC,IAAI,EACJ,EAAE,EACF,QAAQ,EACR,IAAI,EACJ,MAAM,GACP,EAAE;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,gBA+EA"}
+{"version":3,"file":"startUpload.d.ts","sourceRoot":"","sources":["../../../../server/plugins/upload/startUpload.ts"],"names":[],"mappings":"AAoBA,wBAA8B,WAAW,CAAC,EACxC,IAAI,EACJ,EAAE,EACF,QAAQ,EACR,IAAI,EACJ,MAAM,GACP,EAAE;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,gBAyFA"}

package/dist/server/plugins/upload/startUpload.js

@@ -6,12 +6,11 @@ import getUploadStatus from "./getUploadStatus.js";
 import { prefix, fileDir, metaDir, uploadChunkDirectory, fetchTimeoutMs, } from "./index.js";
 import mimes from "../file/providers/mime/mimes.js";
 import { startUpload as startUploadS3 } from "./s3.js";
+import { BadRequestError } from "../../../errors.js";
+const { chunkSize = 5242880 } = config;
 export default async function startUpload({ host, id, fileName, size, subdir, }) {
     if (subdir && (typeof subdir !== "string" || subdir.includes(".."))) {
-        return {
-            error: "invalid params: subdir",
-            code: 400,
-        };
+        throw BadRequestError("invalid params: subdir");
     }
     if (!host) {
         const id1 = id || randomUUID();
@@ -20,14 +19,19 @@ export default async function startUpload({ host, id, fileName, size, subdir, })
             .join(uploadChunkDirectory, subdir || "")
             .replace(/\\/g, "/");
         if (config.s3) {
-            const filepath = path.posix.join(config.folder || '', relativeDirpath, `${id1}.${extension}`);
+            const filepath = path.posix.join(config.folder || "", relativeDirpath, `${id1}.${extension}`);
             const { UploadId } = await startUploadS3({
                 Bucket: config.s3?.containerName || "work",
                 Key: filepath[0] === "/" ? filepath?.slice(1) : filepath,
                 ContentType: mimes[extension],
                 fileSize: size,
             });
-            return { id: UploadId, UploadId, provider: "s3" };
+            return {
+                id: UploadId,
+                UploadId,
+                provider: "s3",
+                chunkSize,
+            };
         }
         const key = id1.split("-").pop();
         const meta = {
@@ -57,10 +61,14 @@ export default async function startUpload({ host, id, fileName, size, subdir, })
             subdir,
             metaPath: undefined,
             relativeDirpath,
-            provider: "fs"
+            provider: "fs",
         };
         await writeFile(path.join(metaDir, `${id1}.json`), JSON.stringify(metaData, null, 2));
-        return { ...meta, metaPath: undefined };
+        return {
+            ...meta,
+            metaPath: undefined,
+            chunkSize,
+        };
     }
     const res = await fetch(`${host}/${prefix}/start`, {
         method: "POST",

package/dist/server/plugins/upload/uploadChunk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../server/plugins/upload/uploadChunk.ts"],"names":[],"mappings":"AAqBA,wBAA8B,WAAW,CAAC,EACxC,IAAI,EACJ,EAAE,EACF,IAAI,EACJ,MAAM,EACN,GAAG,EACH,IAAI,GACL,EAAE;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,GAAG,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd,gBAwIA"}
+{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../server/plugins/upload/uploadChunk.ts"],"names":[],"mappings":"AAwBA,wBAA8B,WAAW,CAAC,EACxC,IAAI,EACJ,EAAE,EACF,IAAI,EACJ,MAAM,EACN,GAAG,EACH,IAAI,GACL,EAAE;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,GAAG,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd,gBA4IA"}

package/dist/server/plugins/upload/uploadChunk.js

@@ -7,11 +7,16 @@ import uploadFile from "../file/uploadFile.js";
 import applyHook from "../hook/applyHook.js";
 import getFileSize from "../file/getFileSize.js";
 import { finishUpload as finishUploadS3, uploadChunk as uploadChunkS3, getUploadStatus as getUploadStatusS3, findUpload as findUploadS3, } from "./s3.js";
+import { BadRequestError, ConflictError, NotFoundError } from "../../../errors.js";
+const { chunkSize = 5242880 } = config;
 export default async function uploadChunk({ host, id, body, offset, end, size, }) {
     if (!host) {
         if (config.s3) {
-            const partNumber = Math.floor(offset / config.chunkSize) + 1;
-            const { fileSize } = await findUploadS3({ id });
+            const partNumber = Math.floor(offset / chunkSize) + 1;
+            const { UploadId, fileSize } = await findUploadS3({ id });
+            if (!UploadId) {
+                throw NotFoundError("upload not found");
+            }
             await uploadChunkS3({
                 id,
                 chunk: body,
@@ -26,17 +31,17 @@ export default async function uploadChunk({ host, id, body, offset, end, size, }
         }
         const metaExists = existsSync(path.join(metaDir, `${id}.json`));
         if (!metaExists) {
-            return { error: "File not found", code: 404 };
+            throw NotFoundError("File not found");
         }
         const meta = JSON.parse(await readFile(path.join(metaDir, `${id}.json`), "utf8"));
         if (size !== meta.size) {
-            return { error: "Total size mismatch", code: 400 };
+            throw BadRequestError("Total size mismatch");
         }
         if (offset !== meta.uploaded) {
-            return { error: "Wrong offset", expected: meta.uploaded, code: 409 };
+            throw ConflictError("Wrong offset");
         }
         if (body?.length !== end - offset + 1) {
-            return { error: "Chunk size mismatch", code: 400 };
+            throw BadRequestError("Chunk size mismatch with Content-Range");
         }
         const relpath = path.posix.join(uploadChunkDirectory, `${id}.${meta.extension}`);
         const res = await getFileSize(relpath, { fallback: false }).catch((err) => ({
@@ -46,10 +51,10 @@ export default async function uploadChunk({ host, id, body, offset, end, size, }
         if (res.error &&
             res.error !== "Error: file not found" &&
             res.code !== "ENOENT") {
-            throw new Error(res.error);
+            throw Error(res.error);
         }
         if (!res.error && res > meta.size) {
-            throw new Error("uploaded size exceeds file size");
+            throw BadRequestError("uploaded size exceeds file size");
         }
         // append chunk to existing file
         await uploadFile(path
@@ -84,7 +89,7 @@ export default async function uploadChunk({ host, id, body, offset, end, size, }
         return { uploaded: meta.uploaded, finished };
     }
     if (!end || !size) {
-        return { error: "not enough params: offset/end/size", code: 400 };
+        throw BadRequestError("not enough params: offset/end/size");
     }
     const url = `${host}/${prefix}/${id}`;
     const range = `bytes ${offset || 0}-${end}/${size}`;

package/dist/server/plugins/usercls/index.js

@@ -1,4 +1,4 @@
-import { NotFoundError } from "../../types/errors.js";
+import { NotFoundError } from "../../../errors.js";
 import pgClients from "../pg/pgClients.js";
 import dataInsert from "../crud/funcs/dataInsert.js";
 import dataUpdate from "../crud/funcs/dataUpdate.js";

package/dist/server/routes/access/controllers/access.group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.group.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAIzD,wBAA8B,WAAW,CACvC,EACE,EAAqB,EACrB,MAAM,EACN,IAAS,GACV,EAAE;IACD,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B,EAED,KAAK,EAAE,YAAY;;;;GA4CpB"}
+{"version":3,"file":"access.group.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAKzD,wBAA8B,WAAW,CACvC,EACE,EAAqB,EACrB,MAAM,EACN,IAAS,GACV,EAAE;IACD,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B,EAED,KAAK,EAAE,YAAY;;;;GAwCpB"}

package/dist/server/routes/access/controllers/access.group.js

@@ -1,16 +1,14 @@
 import { pgClients, getAdminAccess } from "../../../../utils.js";
+import { BadRequestError } from "../../../../errors.js";
 export default async function accessGroup({ pg = pgClients.client, params, user = {}, }, reply) {
     if (!params?.id) {
-        return reply.status(400).send("not enough params: id");
+        throw BadRequestError("not enough params: id");
     }
     // restrict access - admin only
-    const check = await getAdminAccess({
+    await getAdminAccess({
         id: params.id,
         user,
     });
-    if (check?.message && check?.status && process.env.NODE_ENV !== "test") {
-        return reply.status(check?.status).send(check?.message);
-    }
     const routes = await pg
         .query(`select a.route_id as path, b.actions from admin.routes a 
     left join admin.role_access b on a.route_id=b.route_id

package/dist/server/routes/access/controllers/access.group.post.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.group.post.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.group.post.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAKzD,wBAA8B,eAAe,CAC3C,EACE,EAAqB,EACrB,MAAM,EACN,IAAS,EACT,IAAS,GACV,EAAE;IACD,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B,EACD,KAAK,EAAE,YAAY;;;;GA+GpB"}
+{"version":3,"file":"access.group.post.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.group.post.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAMzD,wBAA8B,eAAe,CAC3C,EACE,EAAqB,EACrB,MAAM,EACN,IAAS,EACT,IAAS,GACV,EAAE;IACD,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B,EACD,KAAK,EAAE,YAAY;;;;GA4GpB"}

package/dist/server/routes/access/controllers/access.group.post.js

@@ -1,15 +1,13 @@
 import { pgClients, getAdminAccess } from "../../../../utils.js";
 import accessGroup from "./access.group.js";
+import { UnauthorizedError } from "../../../../errors.js";
 export default async function accessGroupPost({ pg = pgClients.client, params, user = {}, body = {}, }, reply) {
     const { id } = params;
     if (!user?.uid) {
-        return reply.status(401).send("unauthorized");
+        throw UnauthorizedError("unauthorized");
     }
     // restrict access - admin only
-    const check = await getAdminAccess({ id, user });
-    if (check?.message && check?.status && process.env.NODE_ENV !== "test") {
-        return reply.status(check?.status).send(check?.message);
-    }
+    await getAdminAccess({ id, user });
     const { users = [], routes = [] } = body;
     if (!routes?.length) {
         await pg.query("delete from admin.role_access where role_id=$1", [id]);

package/dist/server/routes/access/controllers/access.interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.interface.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAqB5C,wBAA8B,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,YAAY;;GAqB1E"}
+{"version":3,"file":"access.interface.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAqB5C,wBAA8B,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,YAAY;;GAkB1E"}

package/dist/server/routes/access/controllers/access.interface.js

@@ -18,13 +18,10 @@ where $1 in (a.route_id, a.alias, a.table_name) and coalesce(b.user_uid, d.user_
 export default async function accessInterface(req, reply) {
     const { pg = pgClients.client, params = {}, user = {}, unittest } = req;
     // restrict access - admin only
-    const check = await getAdminAccess({
+    await getAdminAccess({
         id: params.name,
         user,
     });
-    if (check?.message && check?.status && !unittest) {
-        return reply.status(check?.status).send(check?.message);
-    }
     const { rows = [] } = await pg.query(q, [params.name]);
     const cls = {
         user_uid: "core.user_uid",

package/dist/server/routes/access/controllers/access.user.d.ts

@@ -1,2 +1,6 @@
-export default function accessUser(req: any, reply: any): Promise<any>;
+export default function accessUser(req: any): Promise<{
+    routes: any;
+    resources: any;
+    user: any;
+}>;
 //# sourceMappingURL=access.user.d.ts.map

package/dist/server/routes/access/controllers/access.user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.user.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.user.ts"],"names":[],"mappings":"AAEA,wBAA8B,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,gBAqC5D"}
+{"version":3,"file":"access.user.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.user.ts"],"names":[],"mappings":"AAGA,wBAA8B,UAAU,CAAC,GAAG,EAAE,GAAG;;;;GAmChD"}

package/dist/server/routes/access/controllers/access.user.js

@@ -1,9 +1,8 @@
+import { BadRequestError } from "../../../../errors.js";
 import { pgClients } from "../../../../utils.js";
-export default async function accessUser(req, reply) {
+export default async function accessUser(req) {
     if (!req.params?.id) {
-        return reply
-            .status(400)
-            .send({ error: "not enough params: id", code: 400 });
+        throw BadRequestError("not enough params: id");
     }
     const { pg = pgClients.client } = req;
     const routes = await pg
@@ -21,5 +20,5 @@ where resource_id is not null and user_uid=$1`, [req.params.id])
     left join admin.users b on a.user_uid=b.uid
     where a.user_uid=$1`, [req.params.id])
         .then((el) => el.rows?.[0]);
-    return reply.status(200).send({ routes, resources, user });
+    return { routes, resources, user };
 }

package/dist/server/routes/access/controllers/access.user.post.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.user.post.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.user.post.ts"],"names":[],"mappings":"AAIA,wBAA8B,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,gBAyDhE"}
+{"version":3,"file":"access.user.post.d.ts","sourceRoot":"","sources":["../../../../../server/routes/access/controllers/access.user.post.ts"],"names":[],"mappings":"AAKA,wBAA8B,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,gBAuDhE"}

package/dist/server/routes/access/controllers/access.user.post.js

@@ -1,14 +1,13 @@
+import { BadRequestError, UnauthorizedError } from "../../../../errors.js";
 import { pgClients } from "../../../../utils.js";
 import accessUser from "./access.user.js";
 export default async function accessUserPost(req, reply) {
     const { pg = pgClients.client, params, body, user } = req;
     if (!params?.id) {
-        return reply
-            .status(400)
-            .send({ error: "not enough params: id", code: 400 });
+        throw BadRequestError("not enough params: id");
     }
     if (!user?.uid) {
-        return reply.status(401).send({ error: "unauthorized", code: 401 });
+        throw UnauthorizedError("unauthorized");
     }
     await pg.query("delete from admin.role_access where user_uid=$1", [
         params.id,
@@ -28,6 +27,6 @@ export default async function accessUserPost(req, reply) {
     await Promise.all(body.routes
         .filter((el) => el.resource && el.actions)
         .map((el) => pg.query("insert into admin.role_access(user_uid,resource_id,actions) values ($1,$2,$3)", [params.id, el.resource, el.actions])));
-    const result = await accessUser({ pg, params }, reply);
+    const result = await accessUser({ pg, params });
     return result;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/routes/access/index.ts"],"names":[],"mappings":"AAgBA,wBAA8B,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAE,GAAQ,iBA8B9D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/routes/access/index.ts"],"names":[],"mappings":"AAkBA,wBAA8B,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAE,GAAQ,iBAqC9D"}