@develit-io/backend-sdk 12.2.1 → 12.3.1

package/dist/index.mjs

@@ -1,4 +1,5 @@
-export { u as uuidv4, a as uuidv5 } from './shared/backend-sdk.D_gzDKeC.mjs';
+import { s as summarizeBinary, a as serializeLog } from './shared/backend-sdk.DANN3OYI.mjs';
+export { u as uuidv4, b as uuidv5 } from './shared/backend-sdk.DANN3OYI.mjs';
 import { sql, inArray, eq, gte, lte, and, or } from 'drizzle-orm';
 import { text, integer } from 'drizzle-orm/sqlite-core';
 import { COUNTRY_CODES_2, CURRENCY_CODES, BANK_CODES } from '@develit-io/general-codes';
@@ -10,7 +11,7 @@ import { parse } from 'comment-json';
 import crypto$1 from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import superjson from 'superjson';
+import 'superjson';
 
 const ENVIRONMENT = ["dev", "test", "staging", "production"];
 
@@ -327,6 +328,8 @@ function redact(value, sensitiveKeys) {
 function redactValue(value, sensitiveKeys, seen) {
   if (value === null || value === void 0) return value;
   if (typeof value !== "object") return value;
+  const binary = summarizeBinary(value);
+  if (binary) return binary;
   const obj = value;
   if (seen.has(obj)) return REDACTED;
   seen.add(obj);
@@ -731,6 +734,7 @@ function nullToOptional(obj) {
   return Object.fromEntries(
     Object.entries(obj).map(([k, v]) => {
       if (v === null) return [k, void 0];
+      if (typeof v === "string") return [k, v.trim() === "" ? void 0 : v];
       if (Array.isArray(v))
         return [
           k,
@@ -908,7 +912,7 @@ function develitWorker(Worker) {
         entrypoint: this.name,
         action: this.action,
         identifier: name,
-        data: superjson.stringify(data)
+        data: serializeLog(data)
       });
     }
     transformLogData(data) {

package/dist/middlewares.mjs

@@ -7,8 +7,9 @@ import 'node:crypto';
 import 'node:fs';
 import 'node:path';
 import 'drizzle-orm';
-import { u as uuidv4 } from './shared/backend-sdk.D_gzDKeC.mjs';
+import { u as uuidv4 } from './shared/backend-sdk.DANN3OYI.mjs';
 import { verifyPayloadSignature } from './utils/signature.util.mjs';
+import 'superjson';
 
 const validateBearerScheme = (header) => {
   return header.startsWith("Bearer ") && header.length > 7 && !header.slice(7).includes(" ");

package/dist/shared/backend-sdk.DANN3OYI.mjs

@@ -0,0 +1,161 @@
+import superjson from 'superjson';
+
+const uuidv4 = () => crypto.randomUUID();
+function parseUUID(uuid) {
+  const hex = uuid.replace(/-/g, "");
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) {
+    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+const uuidv5 = async (name, namespace) => {
+  const namespaceBytes = parseUUID(namespace);
+  const nameBytes = new TextEncoder().encode(name);
+  const data = new Uint8Array(namespaceBytes.length + nameBytes.length);
+  data.set(namespaceBytes);
+  data.set(nameBytes, namespaceBytes.length);
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+  const bytes = new Uint8Array(hashBuffer);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes.slice(0, 16)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+};
+
+function summarizeBinary(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  if (ArrayBuffer.isView(value)) {
+    return {
+      _type: value.constructor?.name ?? "TypedArray",
+      byteLength: value.byteLength
+    };
+  }
+  if (value instanceof ArrayBuffer) {
+    return { _type: "ArrayBuffer", byteLength: value.byteLength };
+  }
+  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+    return { _type: "SharedArrayBuffer", byteLength: value.byteLength };
+  }
+  if (typeof File !== "undefined" && value instanceof File) {
+    return {
+      _type: "File",
+      name: value.name,
+      size: value.size,
+      type: value.type
+    };
+  }
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    return { _type: "Blob", size: value.size, type: value.type };
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    return { _type: "ReadableStream" };
+  }
+  return void 0;
+}
+
+const DEFAULT_LOG_BOUND_LIMITS = {
+  maxStringLength: 2048,
+  maxArrayLength: 100,
+  maxObjectKeys: 200,
+  maxDepth: 12
+};
+const MAX_LOG_BYTES = 64 * 1024;
+const encoder = new TextEncoder();
+function truncateString(value, max) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}\u2026[truncated, ${value.length} chars total]`;
+}
+function boundValue(value, limits, depth, seen) {
+  if (value === null || value === void 0) return value;
+  const type = typeof value;
+  if (type === "string")
+    return truncateString(value, limits.maxStringLength);
+  if (type !== "object") return value;
+  const binary = summarizeBinary(value);
+  if (binary) return binary;
+  const obj = value;
+  if (seen.has(obj)) return "[Circular]";
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: truncateString(value.message ?? "", limits.maxStringLength),
+      stack: truncateString(value.stack ?? "", limits.maxStringLength)
+    };
+  }
+  if (value instanceof Date || value instanceof RegExp || value instanceof URL) {
+    return value;
+  }
+  if (depth >= limits.maxDepth) return "[truncated: max depth]";
+  seen.add(obj);
+  if (Array.isArray(value)) {
+    const kept = value.slice(0, limits.maxArrayLength).map((item) => boundValue(item, limits, depth + 1, seen));
+    if (value.length > limits.maxArrayLength) {
+      kept.push(`\u2026[+${value.length - limits.maxArrayLength} more items]`);
+    }
+    return kept;
+  }
+  if (value instanceof Map) {
+    const out = /* @__PURE__ */ new Map();
+    let i = 0;
+    for (const [key, item] of value) {
+      if (i++ >= limits.maxObjectKeys) break;
+      out.set(key, boundValue(item, limits, depth + 1, seen));
+    }
+    if (value.size > limits.maxObjectKeys) {
+      out.set("\u2026", `[+${value.size - limits.maxObjectKeys} more entries]`);
+    }
+    return out;
+  }
+  if (value instanceof Set) {
+    const out = /* @__PURE__ */ new Set();
+    let i = 0;
+    for (const item of value) {
+      if (i++ >= limits.maxArrayLength) break;
+      out.add(boundValue(item, limits, depth + 1, seen));
+    }
+    if (value.size > limits.maxArrayLength) {
+      out.add(`\u2026[+${value.size - limits.maxArrayLength} more items]`);
+    }
+    return out;
+  }
+  const record = value;
+  const keys = Object.keys(record);
+  const result = {};
+  for (const key of keys.slice(0, limits.maxObjectKeys)) {
+    result[key] = boundValue(record[key], limits, depth + 1, seen);
+  }
+  if (keys.length > limits.maxObjectKeys) {
+    result["\u2026"] = `[+${keys.length - limits.maxObjectKeys} more keys]`;
+  }
+  return result;
+}
+function boundLogData(data, limits = DEFAULT_LOG_BOUND_LIMITS) {
+  return boundValue(data, limits, 0, /* @__PURE__ */ new WeakSet());
+}
+function serializeLog(data, limits = DEFAULT_LOG_BOUND_LIMITS) {
+  try {
+    const serialized = superjson.stringify(boundLogData(data, limits));
+    const byteLength = encoder.encode(serialized).length;
+    if (byteLength <= MAX_LOG_BYTES) return serialized;
+    return superjson.stringify({
+      _truncated: true,
+      reason: "log entry exceeded size cap",
+      bytes: byteLength,
+      preview: serialized.slice(0, 2048)
+    });
+  } catch (error) {
+    return superjson.stringify({
+      _logSerializationError: true,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+
+export { serializeLog as a, uuidv5 as b, summarizeBinary as s, uuidv4 as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@develit-io/backend-sdk",
-  "version": "12.2.1",
+  "version": "12.3.1",
   "description": "Develit Backend SDK",
   "author": "Develit.io",
   "license": "ISC",

package/dist/shared/backend-sdk.D_gzDKeC.mjs

@@ -1,30 +0,0 @@
-const uuidv4 = () => crypto.randomUUID();
-function parseUUID(uuid) {
-  const hex = uuid.replace(/-/g, "");
-  const bytes = new Uint8Array(16);
-  for (let i = 0; i < 16; i++) {
-    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-const uuidv5 = async (name, namespace) => {
-  const namespaceBytes = parseUUID(namespace);
-  const nameBytes = new TextEncoder().encode(name);
-  const data = new Uint8Array(namespaceBytes.length + nameBytes.length);
-  data.set(namespaceBytes);
-  data.set(nameBytes, namespaceBytes.length);
-  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
-  const bytes = new Uint8Array(hashBuffer);
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = [...bytes.slice(0, 16)].map((b) => b.toString(16).padStart(2, "0")).join("");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20, 32)
-  ].join("-");
-};
-
-export { uuidv5 as a, uuidv4 as u };