@arcote.tech/arc-adapter-db-postgres 0.7.26 → 0.7.28

package/dist/index.js

@@ -1779,9 +1779,21 @@ class LocalEventPublisher {
   views = [];
   syncCallback;
   subscribers = new Map;
+  pending = new Set;
   constructor(dataStorage) {
     this.dataStorage = dataStorage;
   }
+  track(work) {
+    const wrapped = Promise.resolve(work).catch(() => {}).finally(() => {
+      this.pending.delete(wrapped);
+    });
+    this.pending.add(wrapped);
+  }
+  async whenIdle() {
+    while (this.pending.size > 0) {
+      await Promise.all([...this.pending]);
+    }
+  }
   onPublish(callback) {
     this.syncCallback = callback;
   }
@@ -1817,9 +1829,12 @@ class LocalEventPublisher {
       store: EVENT_TABLES.events,
       changes: [{ type: "set", data: storedEvent }]
     });
-    if (event.payload && typeof event.payload === "object") {
+    const tagFields = event.definition?.tagFields ?? [];
+    if (tagFields.length > 0 && event.payload && typeof event.payload === "object") {
+      const payload = event.payload;
       const tagChanges = [];
-      for (const [key, value] of Object.entries(event.payload)) {
+      for (const key of tagFields) {
+        const value = payload[key];
         if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
           tagChanges.push({
             type: "set",
@@ -1977,6 +1992,47 @@ class LocalEventPublisher {
     return allViewChanges;
   }
 }
+function murmurHash(key, seed = 0) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3;
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 3432918353;
+  c2 = 461845907;
+  i = 0;
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
+    ++i;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
+    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
+  }
+  k1 = 0;
+  if (remainder >= 3) {
+    k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+  }
+  if (remainder >= 2) {
+    k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+  }
+  if (remainder >= 1) {
+    k1 ^= key.charCodeAt(i) & 255;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
 class ArcOptional {
   parent;
   constructor(parent) {
@@ -2002,6 +2058,11 @@ class ArcOptional {
       return false;
     return this.parent.validate(value);
   }
+  coerce(value) {
+    if (value == null)
+      return;
+    return this.parent.coerce(value);
+  }
   toJsonSchema() {
     const parentSchema = this.parent.toJsonSchema?.() ?? {};
     return {
@@ -2048,6 +2109,9 @@ class ArcBranded {
   validate(value) {
     return this.parent.validate(value);
   }
+  coerce(value) {
+    return this.parent.coerce(value);
+  }
   toJsonSchema() {
     return this.parent.toJsonSchema?.() ?? {};
   }
@@ -2068,7 +2132,14 @@ class ArcDefault {
     this.defaultValueOrCallback = defaultValueOrCallback;
   }
   validate(value) {
-    throw new Error("Method not implemented.");
+    if (value === undefined || value === null)
+      return false;
+    return this.parent.validate(value);
+  }
+  coerce(value) {
+    if (value === undefined || value === null)
+      return;
+    return this.parent.coerce(value);
   }
   parse(value) {
     if (value)
@@ -2152,6 +2223,9 @@ class ArcAbstract {
     }
     return false;
   }
+  coerce(value) {
+    return this.validate(value) ? undefined : value;
+  }
   pipeValidation(name, validator) {
     const newInstance = this.clone();
     newInstance.validations = [...this.validations, { name, validator }];
@@ -2289,6 +2363,17 @@ class ArcArray extends ArcAbstract {
         return { msg: "array is empty" };
     });
   }
+  coerce(value) {
+    if (!Array.isArray(value))
+      return;
+    const out = [];
+    for (const item of value) {
+      const coerced = this.parent.coerce(item);
+      if (coerced !== undefined)
+        out.push(coerced);
+    }
+    return this.validate(out) ? undefined : out;
+  }
   parse(value) {
     return value.map((v) => this.parent.parse(v));
   }
@@ -2360,6 +2445,19 @@ class ArcObject extends ArcAbstract {
     ]);
     this.rawShape = rawShape;
   }
+  coerce(value) {
+    if (value == null || typeof value !== "object" || Array.isArray(value)) {
+      return;
+    }
+    const src = value;
+    const out = {};
+    for (const [key, element] of Object.entries(this.rawShape)) {
+      const coerced = element.coerce(src[key]);
+      if (coerced !== undefined)
+        out[key] = coerced;
+    }
+    return this.validate(out) ? undefined : out;
+  }
   parse(value) {
     return Object.entries(this.rawShape).reduce((acc, [key, element]) => {
       acc[key] = element.parse(value[key]);
@@ -2594,6 +2692,51 @@ class ScopedDataStorage extends DataStorage {
     return this.#inner.getReadWriteTransaction();
   }
 }
+class ArcAuthenticationError extends Error {
+  arcCode = "AUTHENTICATION";
+  constructor(message = "Authentication required") {
+    super(message);
+    this.name = "ArcAuthenticationError";
+  }
+}
+
+class ArcAuthorizationError extends Error {
+  arcCode = "AUTHORIZATION";
+  constructor(message = "Forbidden") {
+    super(message);
+    this.name = "ArcAuthorizationError";
+  }
+}
+function collectFieldPaths(errors, prefix = "") {
+  if (!errors || typeof errors !== "object")
+    return [];
+  const schema = errors.schema;
+  if (!schema || typeof schema !== "object")
+    return [];
+  const out = [];
+  for (const [field, fieldError] of Object.entries(schema)) {
+    if (!fieldError)
+      continue;
+    const path = prefix ? `${prefix}.${field}` : field;
+    const nested = collectFieldPaths(fieldError, path);
+    if (nested.length > 0)
+      out.push(...nested);
+    else
+      out.push(path);
+  }
+  return out;
+}
+
+class ArcValidationError extends Error {
+  arcCode = "VALIDATION";
+  fields;
+  constructor(errors, message = "Invalid parameters") {
+    super(message);
+    this.name = "ArcValidationError";
+    const paths = collectFieldPaths(errors);
+    this.fields = paths.length > 0 ? paths : errors && typeof errors === "object" ? Object.keys(errors) : [];
+  }
+}
 class ArcPrimitive extends ArcAbstract {
   serialize(value) {
     return value;
@@ -2766,6 +2909,8 @@ class ArcFragmentBase {
 class ArcContextElement extends ArcFragmentBase {
   name;
   types = ["context-element"];
+  __contextId;
+  __contextName;
   get id() {
     return this.name;
   }
@@ -2956,7 +3101,8 @@ class ArcEvent extends ArcContextElement {
           payload,
           id: this.eventId.generate(),
           createdAt: new Date,
-          authContext
+          authContext,
+          definition: this
         };
         await adapters.eventPublisher.publish(event);
       }
@@ -3009,8 +3155,8 @@ class ArcEvent extends ArcContextElement {
     const tagsSchema = new ArcObject({
       _id: new ArcString().primaryKey(),
       eventId: new ArcString().index(),
-      tagKey: new ArcString().index(),
-      tagValue: new ArcString().index()
+      tagKey: new ArcString,
+      tagValue: new ArcString
     });
     const syncStatusSchema = new ArcObject({
       _id: new ArcString().primaryKey(),
@@ -3105,6 +3251,27 @@ class ArcFunction {
   get results() {
     return this.data.results;
   }
+  validateParams(params) {
+    const schema = this.data.params;
+    if (!schema || typeof schema.validate !== "function")
+      return;
+    const errors = schema.validate(params ?? {});
+    if (errors)
+      throw new ArcValidationError(errors);
+  }
+  async authorize(adapters) {
+    if (!this.hasProtections)
+      return;
+    const decoded = adapters.authAdapter?.getDecoded?.();
+    if (!decoded) {
+      throw new ArcAuthenticationError;
+    }
+    const instances = this.data.protections.filter((p) => p.token?.name === decoded.tokenName).map((p) => p.token.create(decoded.params, adapters));
+    const ok = await this.verifyProtections(instances);
+    if (!ok) {
+      throw new ArcAuthorizationError;
+    }
+  }
   async verifyProtections(tokens) {
     if (!this.data.protections || this.data.protections.length === 0) {
       return true;
@@ -3265,6 +3432,8 @@ class ArcCommand extends ArcContextElement {
     if (!this.data.handler) {
       throw new Error(`Command "${this.data.name}" has no handler`);
     }
+    this.#fn.validateParams(params);
+    await this.#fn.authorize(adapters);
     const context2 = this.buildCommandContext(adapters);
     return await this.data.handler(context2, params);
   }
@@ -3375,9 +3544,10 @@ class ArcListener extends ArcContextElement {
       }
     }
     if (this.data.isAsync) {
-      Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
+      const work = Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
         console.error(`Async listener "${this.data.name}" error:`, error);
       });
+      adapters.eventPublisher?.track?.(work);
     } else {
       await this.data.handler(context2, event2);
     }
@@ -3584,48 +3754,6 @@ function deepMerge(target, source) {
 function isPlainObject(item) {
   return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
 }
-function murmurHash(key, seed = 0) {
-  let remainder, bytes, h1, h1b, c1, c2, k1, i;
-  remainder = key.length & 3;
-  bytes = key.length - remainder;
-  h1 = seed;
-  c1 = 3432918353;
-  c2 = 461845907;
-  i = 0;
-  while (i < bytes) {
-    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
-    ++i;
-    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
-    k1 = k1 << 15 | k1 >>> 17;
-    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
-    h1 ^= k1;
-    h1 = h1 << 13 | h1 >>> 19;
-    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
-    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
-  }
-  k1 = 0;
-  if (remainder >= 3) {
-    k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
-  }
-  if (remainder >= 2) {
-    k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
-  }
-  if (remainder >= 1) {
-    k1 ^= key.charCodeAt(i) & 255;
-    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
-    k1 = k1 << 15 | k1 >>> 17;
-    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
-    h1 ^= k1;
-  }
-  h1 ^= key.length;
-  h1 ^= h1 >>> 16;
-  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
-  h1 ^= h1 >>> 13;
-  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
-  h1 ^= h1 >>> 16;
-  return h1 >>> 0;
-}
-
 class ForkedStoreState extends StoreState {
   master;
   changedItems = new Map;
@@ -3969,16 +4097,57 @@ function resolveQueryChange(currentResult, event3, options) {
   }
   const shouldBeInResult = checkItemMatchesWhere(event3.item, options.where);
   if (isInCurrentResult && shouldBeInResult) {
-    const newResult = currentResult.toSpliced(index, 1, event3.item);
-    return applyOrderByAndLimit(newResult, options);
+    if (!options.orderBy) {
+      return applyLimit(currentResult.toSpliced(index, 1, event3.item), options);
+    }
+    const cmp = compareByOrderBy(options.orderBy);
+    if (cmp(currentResult[index], event3.item) === 0) {
+      return applyLimit(currentResult.toSpliced(index, 1, event3.item), options);
+    }
+    const without = currentResult.toSpliced(index, 1);
+    const at = upperBound(without, event3.item, cmp);
+    return applyLimit(without.toSpliced(at, 0, event3.item), options);
   } else if (isInCurrentResult && !shouldBeInResult) {
     return currentResult.toSpliced(index, 1);
   } else if (!isInCurrentResult && shouldBeInResult) {
-    const newResult = [...currentResult, event3.item];
-    return applyOrderByAndLimit(newResult, options);
+    if (!options.orderBy) {
+      return applyLimit([...currentResult, event3.item], options);
+    }
+    const cmp = compareByOrderBy(options.orderBy);
+    const at = upperBound(currentResult, event3.item, cmp);
+    return applyLimit(currentResult.toSpliced(at, 0, event3.item), options);
   }
   return false;
 }
+function compareByOrderBy(orderBy) {
+  const entries = Object.entries(orderBy);
+  return (a, b) => {
+    for (const [key, direction] of entries) {
+      const aVal = a[key];
+      const bVal = b[key];
+      if (aVal < bVal)
+        return direction === "asc" ? -1 : 1;
+      if (aVal > bVal)
+        return direction === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+}
+function upperBound(arr, item, cmp) {
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (cmp(arr[mid], item) <= 0)
+      lo = mid + 1;
+    else
+      hi = mid;
+  }
+  return lo;
+}
+function applyLimit(result, options) {
+  return options.limit !== undefined && result.length > options.limit ? result.slice(0, options.limit) : result;
+}
 function checkItemMatchesWhere(item, where) {
   if (!where) {
     return true;
@@ -4014,27 +4183,6 @@ function checkItemMatchesWhere(item, where) {
     });
   });
 }
-function applyOrderByAndLimit(result, options) {
-  let sorted = result;
-  if (options.orderBy) {
-    sorted = [...result].sort((a, b) => {
-      for (const [key, direction] of Object.entries(options.orderBy)) {
-        const aVal = a[key];
-        const bVal = b[key];
-        if (aVal < bVal)
-          return direction === "asc" ? -1 : 1;
-        if (aVal > bVal)
-          return direction === "asc" ? 1 : -1;
-      }
-      return 0;
-    });
-  }
-  if (options.limit !== undefined) {
-    sorted = sorted.slice(0, options.limit);
-  }
-  return sorted;
-}
-
 class ObservableDataStorage {
   source;
   onChange;
@@ -4682,6 +4830,8 @@ class SecuredDataStorage {
     return this.dataStorage.fork();
   }
 }
+var _te = new TextEncoder;
+var _td = new TextDecoder;
 class TokenCache {
   instanceCache = new Map;
   permissionCache = new Map;
@@ -5249,7 +5399,7 @@ kebab.column.to = fromKebab;
 // ../../../../node_modules/.bun/postgres@3.4.9/node_modules/postgres/src/connection.js
 import net from "net";
 import tls from "tls";
-import crypto from "crypto";
+import crypto2 from "crypto";
 import Stream from "stream";
 import { performance } from "perf_hooks";
 
@@ -5830,14 +5980,14 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     write(bytes_default().p().str(payload).z(1).end());
   }
   async function SASL() {
-    nonce = (await crypto.randomBytes(18)).toString("base64");
+    nonce = (await crypto2.randomBytes(18)).toString("base64");
     bytes_default().p().str("SCRAM-SHA-256" + bytes_default.N);
     const i = bytes_default.i;
     write(bytes_default.inc(4).str("n,,n=*,r=" + nonce).i32(bytes_default.i - i - 4, i).end());
   }
   async function SASLContinue(x) {
     const res = x.toString("utf8", 9).split(",").reduce((acc, x2) => (acc[x2[0]] = x2.slice(2), acc), {});
-    const saltedPassword = await crypto.pbkdf2Sync(await Pass(), Buffer.from(res.s, "base64"), parseInt(res.i), 32, "sha256");
+    const saltedPassword = await crypto2.pbkdf2Sync(await Pass(), Buffer.from(res.s, "base64"), parseInt(res.i), 32, "sha256");
     const clientKey = await hmac(saltedPassword, "Client Key");
     const auth = "n=*,r=" + nonce + "," + "r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
     serverSignature = (await hmac(await hmac(saltedPassword, "Server Key"), auth)).toString("base64");
@@ -6058,13 +6208,13 @@ function parseError(x) {
   return error;
 }
 function md5(x) {
-  return crypto.createHash("md5").update(x).digest("hex");
+  return crypto2.createHash("md5").update(x).digest("hex");
 }
 function hmac(key, x) {
-  return crypto.createHmac("sha256", key).update(x).digest();
+  return crypto2.createHmac("sha256", key).update(x).digest();
 }
 function sha256(x) {
-  return crypto.createHash("sha256").update(x).digest();
+  return crypto2.createHash("sha256").update(x).digest();
 }
 function xor(a, b2) {
   const length = Math.max(a.length, b2.length);
@@ -6751,6 +6901,40 @@ function osUsername() {
 }
 
 // src/postgres-adapter.ts
+var MAX_SAFE_INT = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE_INT = BigInt(Number.MIN_SAFE_INTEGER);
+function unsafeIntMessage(raw, columnName) {
+  const where = columnName ? ` w kolumnie "${columnName}"` : "";
+  return `[PostgreSQL] Wartość całkowita ${raw}${where} przekracza bezpieczny zakres ` + `JS Number (±2^53-1). Odczyt jako number cicho straciłby precyzję. ` + `Użyj kolumny TEXT/NUMERIC i obsłuż wartość jako string/BigInt.`;
+}
+function coercePgNumber(value, columnName) {
+  if (value === null || value === undefined)
+    return value;
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint") {
+    if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {
+      throw new Error(unsafeIntMessage(value.toString(), columnName));
+    }
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (s === "")
+      return value;
+    if (/^[+-]?\d+$/.test(s)) {
+      const big = BigInt(s);
+      if (big > MAX_SAFE_INT || big < MIN_SAFE_INT) {
+        throw new Error(unsafeIntMessage(s, columnName));
+      }
+      return Number(big);
+    }
+    const n = Number(s);
+    return Number.isNaN(n) ? value : n;
+  }
+  return value;
+}
+
 class PostgreSQLReadTransaction {
   db;
   tables;
@@ -6772,7 +6956,27 @@ class PostgreSQLReadTransaction {
   deserializeValue(value, column) {
     if (value === null || value === undefined)
       return null;
-    switch (column.type.toLowerCase()) {
+    const type = column.type.toLowerCase().split("(")[0].trim();
+    switch (type) {
+      case "bigint":
+      case "int8":
+      case "bigserial":
+      case "serial8":
+      case "serial":
+      case "serial4":
+      case "integer":
+      case "int":
+      case "int4":
+      case "smallint":
+      case "int2":
+      case "numeric":
+      case "decimal":
+      case "real":
+      case "double precision":
+      case "float":
+      case "float4":
+      case "float8":
+        return coercePgNumber(value, column.name);
       case "json":
       case "jsonb":
         if (typeof value === "string") {
@@ -7423,7 +7627,15 @@ class PostgresJsDatabase {
 }
 var createPostgreSQLAdapterFactoryFromUrl = (connectionString) => {
   const sql = src_default(connectionString, {
-    onnotice: () => {}
+    onnotice: () => {},
+    types: {
+      bigint: {
+        to: 20,
+        from: [20],
+        serialize: (v) => v.toString(),
+        parse: (v) => coercePgNumber(v)
+      }
+    }
   });
   const db = new PostgresJsDatabase(sql);
   return createPostgreSQLAdapterFactory(db);
@@ -7431,5 +7643,6 @@ var createPostgreSQLAdapterFactoryFromUrl = (connectionString) => {
 export {
   createPostgreSQLAdapterFactoryFromUrl,
   createPostgreSQLAdapterFactory,
+  coercePgNumber,
   PostgreSQLAdapter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-postgres",
-  "version": "0.7.26",
+  "version": "0.7.28",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     "postgres": "^3.4.4"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.7.26"
+    "@arcote.tech/arc": "^0.7.28"
   },
   "devDependencies": {
     "@types/pg": "^8.11.0",