@arcote.tech/arc-adapter-db-postgres 0.4.7 → 0.5.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// ../../../../node_modules/mutative/dist/mutative.esm.mjs
+// ../../../../node_modules/.bun/mutative@1.3.0/node_modules/mutative/dist/mutative.esm.mjs
 var Operation = {
   Remove: "remove",
   Replace: "replace",
@@ -1354,14 +1354,23 @@ var TOKEN_PREFIX = "arc:token:";
 function hasLocalStorage() {
   return typeof localStorage !== "undefined";
 }
+function notifyTokenChange(scope) {
+  if (typeof window !== "undefined") {
+    queueMicrotask(() => {
+      window.dispatchEvent(new CustomEvent("arc:token-change", { detail: { scope } }));
+    });
+  }
+}
 
 class AuthAdapter {
   scopes = new Map;
   setToken(token, scope = "default") {
     if (!token) {
       this.scopes.delete(scope);
-      if (hasLocalStorage())
+      if (hasLocalStorage()) {
         localStorage.removeItem(TOKEN_PREFIX + scope);
+        notifyTokenChange(scope);
+      }
       return;
     }
     try {
@@ -1382,8 +1391,10 @@ class AuthAdapter {
           exp: payload.exp
         }
       });
-      if (hasLocalStorage())
+      if (hasLocalStorage()) {
         localStorage.setItem(TOKEN_PREFIX + scope, token);
+        notifyTokenChange(scope);
+      }
     } catch {
       this.scopes.delete(scope);
       if (hasLocalStorage())
@@ -2815,6 +2826,147 @@ class ArcEvent extends ArcContextElement {
     return ArcEvent.sharedDatabaseStoreSchema();
   }
 }
+function buildElementContext(queryElements, mutationElements, adapters) {
+  const queryMap = new Map;
+  const mutateMap = new Map;
+  const queryProps = {};
+  for (const element of queryElements) {
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      queryProps[element.name] = ctx;
+      queryMap.set(element, ctx);
+    }
+  }
+  const mutateProps = {};
+  for (const element of mutationElements) {
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      mutateProps[element.name] = ctx;
+      mutateMap.set(element, ctx);
+    }
+  }
+  const queryFn = (element) => {
+    const cached = queryMap.get(element);
+    if (cached)
+      return cached;
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      queryMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no queryContext`);
+  };
+  Object.assign(queryFn, queryProps);
+  const mutateFn = (element) => {
+    const cached = mutateMap.get(element);
+    if (cached)
+      return cached;
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      mutateMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no mutateContext`);
+  };
+  Object.assign(mutateFn, mutateProps);
+  return {
+    query: queryFn,
+    mutate: mutateFn
+  };
+}
+
+class ArcFunction {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+  withParams(schema) {
+    return new ArcFunction({
+      ...this.data,
+      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  withResult(schema) {
+    return new ArcFunction({
+      ...this.data,
+      result: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  query(elements) {
+    return new ArcFunction({
+      ...this.data,
+      queryElements: elements
+    });
+  }
+  mutate(elements) {
+    return new ArcFunction({
+      ...this.data,
+      mutationElements: elements
+    });
+  }
+  protectedBy(token, check) {
+    const existingProtections = this.data.protections || [];
+    return new ArcFunction({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    });
+  }
+  description(desc) {
+    return new ArcFunction({
+      ...this.data,
+      description: desc
+    });
+  }
+  handle(handler) {
+    return new ArcFunction({
+      ...this.data,
+      handler
+    });
+  }
+  get isPublic() {
+    return !this.hasProtections;
+  }
+  get hasProtections() {
+    return (this.data.protections?.length ?? 0) > 0;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  get handler() {
+    return this.data.handler;
+  }
+  get params() {
+    return this.data.params;
+  }
+  get result() {
+    return this.data.result;
+  }
+  async verifyProtections(tokens) {
+    if (!this.data.protections || this.data.protections.length === 0) {
+      return true;
+    }
+    for (const protection of this.data.protections) {
+      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
+      if (!tokenInstance) {
+        return false;
+      }
+      const result = await protection.check(tokenInstance);
+      if (result === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+  buildContext(adapters) {
+    return buildElementContext(this.data.queryElements || [], this.data.mutationElements || [], adapters);
+  }
+  toJsonSchema() {
+    return {
+      params: this.data.params?.toJsonSchema?.() ?? null,
+      result: this.data.result?.toJsonSchema?.() ?? null
+    };
+  }
+}
 class AggregateBase {
   value;
   _id;
@@ -2852,6 +3004,315 @@ class AggregateBase {
     return result;
   }
 }
+class ArcCommand extends ArcContextElement {
+  data;
+  #fn;
+  constructor(data, fn) {
+    super(data.name);
+    this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: data.params,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: data.protections || [],
+      handler: data.handler ?? null,
+      description: data.description
+    });
+  }
+  description(description) {
+    const newFn = this.#fn.description(description);
+    return new ArcCommand({ ...this.data, description }, newFn);
+  }
+  get isPublic() {
+    return this.#fn.isPublic;
+  }
+  query(elements) {
+    const newFn = this.#fn.query(elements);
+    return new ArcCommand({ ...this.data, queryElements: elements }, newFn);
+  }
+  mutate(elements) {
+    const newFn = this.#fn.mutate(elements);
+    return new ArcCommand({ ...this.data, mutationElements: elements }, newFn);
+  }
+  withParams(schema) {
+    const newFn = this.#fn.withParams(schema);
+    return new ArcCommand({
+      ...this.data,
+      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    }, newFn);
+  }
+  withResult(...schemas) {
+    return new ArcCommand({ ...this.data, results: schemas }, this.#fn);
+  }
+  handle(handler) {
+    const newFn = new ArcFunction({
+      ...this.#fn.data,
+      handler
+    });
+    return new ArcCommand({ ...this.data, handler }, newFn);
+  }
+  protectBy(token, check) {
+    const newFn = this.#fn.protectedBy(token, check);
+    const existingProtections = this.data.protections || [];
+    return new ArcCommand({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    }, newFn);
+  }
+  get hasProtections() {
+    return this.#fn.hasProtections;
+  }
+  get protections() {
+    return this.#fn.protections;
+  }
+  async verifyProtections(tokens) {
+    return this.#fn.verifyProtections(tokens);
+  }
+  async init(environment, adapters) {
+    if (environment === "server" && this.data.handler && adapters.commandWire?.registerCommandHandler) {
+      adapters.commandWire.registerCommandHandler(this.data.name, async (params) => {
+        const executeFunc = this.mutateContext(adapters);
+        return await executeFunc(params);
+      });
+    }
+  }
+  mutateContext(adapters) {
+    const executeFunc = async (params) => {
+      if (this.data.handler) {
+        return await this.executeLocally(params, adapters);
+      }
+      if (!adapters.commandWire) {
+        throw new Error(`Command "${this.data.name}" has no handler and no commandWire adapter available for remote execution`);
+      }
+      return await adapters.commandWire.executeCommand(this.data.name, params);
+    };
+    return Object.assign(executeFunc, { params: this.data.params });
+  }
+  async executeLocally(params, adapters) {
+    if (!this.data.handler) {
+      throw new Error(`Command "${this.data.name}" has no handler`);
+    }
+    const context2 = this.buildCommandContext(adapters);
+    return await this.data.handler(context2, params);
+  }
+  buildCommandContext(adapters) {
+    const context2 = this.#fn.buildContext(adapters);
+    if (this.#fn.hasProtections && adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      if (decoded) {
+        context2.$auth = {
+          params: decoded.params,
+          tokenName: decoded.tokenName
+        };
+      } else {
+        throw new Error(`Command "${this.data.name}" requires authentication but no valid token found`);
+      }
+    }
+    return context2;
+  }
+  toJsonSchema() {
+    const parametersSchema = this.data.params ? this.data.params.toJsonSchema?.() ?? {
+      type: "object",
+      properties: {}
+    } : { type: "object", properties: {} };
+    return {
+      type: "function",
+      name: this.data.name,
+      description: this.data.description ?? undefined,
+      parameters: parametersSchema,
+      strict: true
+    };
+  }
+}
+class ArcListener extends ArcContextElement {
+  data;
+  #fn;
+  unsubscribers = [];
+  constructor(data, fn) {
+    super(data.name);
+    this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: null,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: [],
+      handler: null,
+      description: data.description
+    });
+  }
+  description(description) {
+    const newFn = this.#fn.description(description);
+    return new ArcListener({ ...this.data, description }, newFn);
+  }
+  listenTo(events) {
+    return new ArcListener({ ...this.data, eventElements: events }, this.#fn);
+  }
+  query(elements) {
+    const newFn = this.#fn.query(elements);
+    return new ArcListener({ ...this.data, queryElements: elements }, newFn);
+  }
+  mutate(elements) {
+    const newFn = this.#fn.mutate(elements);
+    return new ArcListener({ ...this.data, mutationElements: elements }, newFn);
+  }
+  async() {
+    return new ArcListener({ ...this.data, isAsync: true }, this.#fn);
+  }
+  handle(handler) {
+    return new ArcListener({ ...this.data, handler }, this.#fn);
+  }
+  get eventElements() {
+    return this.data.eventElements || [];
+  }
+  get isAsync() {
+    return this.data.isAsync;
+  }
+  async init(environment, adapters) {
+    if (environment !== "server") {
+      return;
+    }
+    if (!this.data.handler) {
+      console.warn(`Listener "${this.data.name}" has no handler`);
+      return;
+    }
+    if (!adapters.eventPublisher) {
+      console.warn(`Listener "${this.data.name}" cannot subscribe: no eventPublisher adapter`);
+      return;
+    }
+    for (const eventElement of this.data.eventElements) {
+      const unsubscribe = adapters.eventPublisher.subscribe(eventElement.name, async (event2) => {
+        await this.handleEvent(event2, adapters);
+      });
+      this.unsubscribers.push(unsubscribe);
+    }
+  }
+  async handleEvent(event2, adapters) {
+    if (!this.data.handler)
+      return;
+    const context2 = this.#fn.buildContext(adapters);
+    if (adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      if (decoded) {
+        context2.$auth = {
+          params: decoded.params,
+          tokenName: decoded.tokenName
+        };
+      }
+    }
+    if (this.data.isAsync) {
+      Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
+        console.error(`Async listener "${this.data.name}" error:`, error);
+      });
+    } else {
+      await this.data.handler(context2, event2);
+    }
+  }
+  destroy() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+}
+class ArcRoute extends ArcContextElement {
+  data;
+  #fn;
+  constructor(data, fn) {
+    super(data.name);
+    this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: null,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: data.protections || [],
+      handler: null,
+      description: data.description
+    });
+  }
+  description(description) {
+    const newFn = this.#fn.description(description);
+    return new ArcRoute({ ...this.data, description }, newFn);
+  }
+  path(path) {
+    return new ArcRoute({ ...this.data, path }, this.#fn);
+  }
+  public() {
+    return new ArcRoute({ ...this.data, isPublic: true }, this.#fn);
+  }
+  query(elements) {
+    const newFn = this.#fn.query(elements);
+    return new ArcRoute({ ...this.data, queryElements: elements }, newFn);
+  }
+  mutate(elements) {
+    const newFn = this.#fn.mutate(elements);
+    return new ArcRoute({ ...this.data, mutationElements: elements }, newFn);
+  }
+  protectBy(token, check) {
+    const newFn = this.#fn.protectedBy(token, check);
+    const existingProtections = this.data.protections || [];
+    return new ArcRoute({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    }, newFn);
+  }
+  handle(handlers) {
+    return new ArcRoute({ ...this.data, handlers }, this.#fn);
+  }
+  get routePath() {
+    return this.data.path || `/${this.data.name}`;
+  }
+  get fullPath() {
+    return `/route${this.routePath}`;
+  }
+  get isPublic() {
+    return this.data.isPublic;
+  }
+  get hasProtections() {
+    return this.#fn.hasProtections;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  getHandler(method) {
+    return this.data.handlers?.[method];
+  }
+  matchesPath(pathname) {
+    const routePath = this.fullPath;
+    const routeParts = routePath.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+    if (routeParts.length !== pathParts.length) {
+      return { matches: false, params: {} };
+    }
+    const params = {};
+    for (let i = 0;i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathPart = pathParts[i];
+      if (routePart.startsWith(":")) {
+        const paramName = routePart.slice(1);
+        params[paramName] = pathPart;
+      } else if (routePart !== pathPart) {
+        return { matches: false, params: {} };
+      }
+    }
+    return { matches: true, params };
+  }
+  async verifyProtections(tokens) {
+    if (this.data.isPublic) {
+      return true;
+    }
+    return this.#fn.verifyProtections(tokens);
+  }
+  buildContext(adapters, authParams) {
+    const context2 = this.#fn.buildContext(adapters);
+    if (authParams) {
+      context2.$auth = authParams;
+    }
+    return context2;
+  }
+}
 class DataStorage {
   async commitChanges(changes) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
@@ -4151,11 +4612,11 @@ class TokenCache {
   }
 }
 
-// ../../../../node_modules/postgres/src/index.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/index.js
 import os from "os";
 import fs from "fs";
 
-// ../../../../node_modules/postgres/src/query.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/query.js
 var originCache = new Map;
 var originStackCache = new Map;
 var originError = Symbol("OriginError");
@@ -4293,7 +4754,7 @@ function cachedError(xs) {
   return originCache.get(xs);
 }
 
-// ../../../../node_modules/postgres/src/errors.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/errors.js
 class PostgresError extends Error {
   constructor(x) {
     super(x.message);
@@ -4336,7 +4797,7 @@ function notSupported(x) {
   return error;
 }
 
-// ../../../../node_modules/postgres/src/types.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/types.js
 var types = {
   string: {
     to: 25,
@@ -4617,14 +5078,14 @@ fromKebab.column = { to: fromKebab };
 var kebab = { ...toKebab };
 kebab.column.to = fromKebab;
 
-// ../../../../node_modules/postgres/src/connection.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/connection.js
 import net from "net";
 import tls from "tls";
 import crypto from "crypto";
 import Stream from "stream";
 import { performance } from "perf_hooks";
 
-// ../../../../node_modules/postgres/src/result.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/result.js
 class Result extends Array {
   constructor() {
     super();
@@ -4641,7 +5102,7 @@ class Result extends Array {
   }
 }
 
-// ../../../../node_modules/postgres/src/queue.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/queue.js
 var queue_default = Queue;
 function Queue(initial = []) {
   let xs = initial.slice();
@@ -4668,7 +5129,7 @@ function Queue(initial = []) {
   };
 }
 
-// ../../../../node_modules/postgres/src/bytes.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/bytes.js
 var size = 256;
 var buffer = Buffer.allocUnsafe(size);
 var messages = "BCcDdEFfHPpQSX".split("").reduce((acc, x) => {
@@ -4741,7 +5202,7 @@ function reset() {
   return b;
 }
 
-// ../../../../node_modules/postgres/src/connection.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/connection.js
 var connection_default = Connection;
 var uid = 1;
 var Sync = bytes_default().S().end();
@@ -4777,6 +5238,7 @@ var errorFields = {
 };
 function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose = noop } = {}) {
   const {
+    sslnegotiation,
     ssl,
     max,
     user,
@@ -4794,7 +5256,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     target_session_attrs
   } = options;
   const sent = queue_default(), id2 = uid++, backend = { pid: null, secret: null }, idleTimer = timer(end, options.idle_timeout), lifeTimer = timer(end, options.max_lifetime), connectTimer = timer(connectTimedOut, options.connect_timeout);
-  let socket = null, cancelMessage, result = new Result, incoming = Buffer.alloc(0), needsTypes = options.fetch_types, backendParameters = {}, statements = {}, statementId = Math.random().toString(36).slice(2), statementCount = 1, closedDate = 0, remaining = 0, hostIndex = 0, retries = 0, length = 0, delay = 0, rows = 0, serverSignature = null, nextWriteTimer = null, terminated = false, incomings = null, results = null, initial = null, ending = null, stream = null, chunk = null, ended = null, nonce = null, query = null, final = null;
+  let socket = null, cancelMessage, errorResponse = null, result = new Result, incoming = Buffer.alloc(0), needsTypes = options.fetch_types, backendParameters = {}, statements = {}, statementId = Math.random().toString(36).slice(2), statementCount = 1, closedTime = 0, remaining = 0, hostIndex = 0, retries = 0, length = 0, delay = 0, rows = 0, serverSignature = null, nextWriteTimer = null, terminated = false, incomings = null, results = null, initial = null, ending = null, stream = null, chunk = null, ended = null, nonce = null, query = null, final = null;
   const connection2 = {
     queue: queues.closed,
     idleTimer,
@@ -4837,6 +5299,8 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function execute(q) {
     if (terminated)
       return queryError(q, Errors.connection("CONNECTION_DESTROYED", options));
+    if (stream)
+      return queryError(q, Errors.generic("COPY_IN_PROGRESS", "You cannot execute queries during copy"));
     if (q.cancelled)
       return;
     try {
@@ -4906,16 +5370,24 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     socket.destroy();
   }
   async function secure() {
-    write(SSLRequest);
-    const canSSL = await new Promise((r) => socket.once("data", (x) => r(x[0] === 83)));
-    if (!canSSL && ssl === "prefer")
-      return connected();
-    socket.removeAllListeners();
-    socket = tls.connect({
+    if (sslnegotiation !== "direct") {
+      write(SSLRequest);
+      const canSSL = await new Promise((r) => socket.once("data", (x) => r(x[0] === 83)));
+      if (!canSSL && ssl === "prefer")
+        return connected();
+    }
+    const options2 = {
       socket,
-      servername: net.isIP(socket.host) ? undefined : socket.host,
-      ...ssl === "require" || ssl === "allow" || ssl === "prefer" ? { rejectUnauthorized: false } : ssl === "verify-full" ? {} : typeof ssl === "object" ? ssl : {}
-    });
+      servername: net.isIP(socket.host) ? undefined : socket.host
+    };
+    if (sslnegotiation === "direct")
+      options2.ALPNProtocols = ["postgresql"];
+    if (ssl === "require" || ssl === "allow" || ssl === "prefer")
+      options2.rejectUnauthorized = false;
+    else if (typeof ssl === "object")
+      Object.assign(options2, ssl);
+    socket.removeAllListeners();
+    socket = tls.connect(options2);
     socket.on("secureConnect", connected);
     socket.on("error", error);
     socket.on("close", closed);
@@ -4969,7 +5441,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     hostIndex = (hostIndex + 1) % port.length;
   }
   function reconnect() {
-    setTimeout(connect, closedDate ? closedDate + delay - performance.now() : 0);
+    setTimeout(connect, closedTime ? Math.max(0, closedTime + delay - performance.now()) : 0);
   }
   function connected() {
     try {
@@ -5043,7 +5515,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     if (initial)
       return reconnect();
     !hadError && (query || sent.length) && error(Errors.connection("CONNECTION_CLOSED", options, socket));
-    closedDate = performance.now();
+    closedTime = performance.now();
     hadError && options.shared.retries++;
     delay = (typeof backoff === "function" ? backoff(options.shared.retries) : backoff) * 1000;
     onclose(connection2, Errors.connection("CONNECTION_CLOSED", options, socket));
@@ -5075,8 +5547,16 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     }
   }
   function ReadyForQuery(x) {
-    query && query.options.simple && query.resolve(results || result);
-    query = results = null;
+    if (query) {
+      if (errorResponse) {
+        query.retried ? errored(query.retried) : query.prepared && retryRoutines.has(errorResponse.routine) ? retry(query, errorResponse) : errored(errorResponse);
+      } else {
+        query.resolve(results || result);
+      }
+    } else if (errorResponse) {
+      errored(errorResponse);
+    }
+    query = results = errorResponse = null;
     result = new Result;
     connectTimer.cancel();
     if (initial) {
@@ -5121,7 +5601,6 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       result.count && query.cursorFn(result);
       write(Sync);
     }
-    query.resolve(result);
   }
   function ParseComplete() {
     query.parsing = false;
@@ -5252,9 +5731,12 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     query2.execute();
   }
   function ErrorResponse(x) {
-    query && (query.cursorFn || query.describeFirst) && write(Sync);
-    const error2 = Errors.postgres(parseError(x));
-    query && query.retried ? errored(query.retried) : query && query.prepared && retryRoutines.has(error2.routine) ? retry(query, error2) : errored(error2);
+    if (query) {
+      (query.cursorFn || query.describeFirst) && write(Sync);
+      errorResponse = Errors.postgres(parseError(x));
+    } else {
+      errored(Errors.postgres(parseError(x)));
+    }
   }
   function retry(q, error2) {
     delete statements[q.signature];
@@ -5297,6 +5779,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       final(callback) {
         socket.write(bytes_default().c().end());
         final = callback;
+        stream = null;
       }
     });
     query.resolve(stream);
@@ -5442,7 +5925,7 @@ function timer(fn, seconds) {
   }
 }
 
-// ../../../../node_modules/postgres/src/subscribe.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/subscribe.js
 var noop2 = () => {};
 function Subscribe(postgres2, options) {
   const subscribers = new Map, slot = "postgresjs_" + Math.random().toString(36).slice(2), state = {};
@@ -5638,7 +6121,7 @@ function parseEvent(x) {
   return (command || "*") + (path ? ":" + (path.indexOf(".") === -1 ? "public." + path : path) : "") + (key ? "=" + key : "");
 }
 
-// ../../../../node_modules/postgres/src/large.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/large.js
 import Stream2 from "stream";
 function largeObject(sql, oid, mode = 131072 | 262144) {
   return new Promise(async (resolve, reject) => {
@@ -5704,7 +6187,7 @@ function largeObject(sql, oid, mode = 131072 | 262144) {
   });
 }
 
-// ../../../../node_modules/postgres/src/index.js
+// ../../../../node_modules/.bun/postgres@3.4.8/node_modules/postgres/src/index.js
 Object.assign(Postgres, {
   PostgresError,
   toPascal,
@@ -5997,8 +6480,9 @@ function parseOptions(a, b2) {
   query.sslrootcert === "system" && (query.ssl = "verify-full");
   const ints = ["idle_timeout", "connect_timeout", "max_lifetime", "max_pipeline", "backoff", "keep_alive"];
   const defaults = {
-    max: 10,
+    max: globalThis.Cloudflare ? 3 : 10,
     ssl: false,
+    sslnegotiation: null,
     idle_timeout: null,
     connect_timeout: 30,
     max_lifetime,

package/package.json

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