@palbase/backend 35.0.1 → 36.0.1

package/dist/{index-E8Sd6NFy.d.ts → index-Ogi30dbt.d.ts}

@@ -1,6 +1,54 @@
-import { c as DatabaseDiagnosticsOptions, d as DatabaseDiagnostics, a as DBClient, T as TransactionIsolation, e as DBOps, P as PreparedRead, C as CompiledRead, f as RawPageOptions, g as Page, h as TxPlanBody, i as CommandOptions, j as TxPlanResponse, A as AuthSpec, k as CacheClient, b as RuntimeServices, _ as __runWithRuntime, l as __requestALS } from './endpoint-BI0yGuEL.js';
+import { c as DatabaseDiagnosticsOptions, d as DatabaseDiagnostics, a as DBClient, T as TransactionIsolation, e as DBOps, f as RawPageOptions, P as Page, g as TxPlanBody, C as CommandOptions, h as TxPlanResponse, A as AuthSpec, i as CacheClient, b as RuntimeServices, _ as __runWithRuntime, j as __requestALS } from './index-CUy50OLU.js';
 import { T as Token } from './module-Dl1KFVtc.js';
-import { R as RouteMeta } from './registry-zDCj0eOU.js';
+import { R as RouteMeta } from './registry-DJcvbomD.js';
+
+interface AdmissionLease {
+    queueMs: number;
+    release(): void;
+}
+/** Deployment settings, never a query/workload declaration in application code. */
+interface DatabaseAdmissionOptions {
+    concurrency: number;
+    queueLimit?: number;
+    queueTimeoutMs?: number;
+    /** Optional signed, issuer-controlled top-level tenant claim. By default
+     * fairness uses verified sub, not the installation-wide tenant_id. */
+    tenantClaim?: string;
+    onReject?: (event: {
+        reason: "full" | "timeout" | "cancelled";
+        active: number;
+        queued: number;
+    }) => void;
+}
+declare class DatabaseAdmission {
+    readonly options: DatabaseAdmissionOptions;
+    private active;
+    private queued;
+    private tenants;
+    private pending;
+    private lastTenant?;
+    private accepted;
+    private rejected;
+    private readonly limit;
+    private readonly timeout;
+    constructor(options: DatabaseAdmissionOptions);
+    get snapshot(): {
+        active: number;
+        queued: number;
+        tenants: number;
+        accepted: number;
+        rejected: {
+            full: number;
+            timeout: number;
+            cancelled: number;
+        };
+    };
+    private rejection;
+    private take;
+    private drain;
+    acquire(claimsJson: string, signal?: AbortSignal): Promise<AdmissionLease>;
+}
+declare function databaseAdmission(owner: object, options?: DatabaseAdmissionOptions): DatabaseAdmission;
 
 /**
  * engine/config.ts — settings from the environment, and the gate that refuses
@@ -70,6 +118,8 @@ interface EngineConfig {
      */
     dbServiceRole: string;
     poolMax: number;
+    /** Internal engine/core deployment policy; application CRUD has no capacity options. */
+    databaseAdmission?: Omit<DatabaseAdmissionOptions, "concurrency">;
     databaseDiagnostics?: DatabaseDiagnosticsOptions;
 }
 /**
@@ -121,7 +171,7 @@ declare class TransactionControl {
     dispose(): void;
 }
 
-type Timing = "queueMs" | "poolMs" | "setupMs" | "sqlMs" | "commitMs" | "rollbackMs";
+type Timing = "queueMs" | "poolMs" | "setupMs" | "sqlMs" | "commitMs" | "rollbackMs" | "connectionMs";
 /** Allocated only when diagnostics or a budget is configured. One collector
  * follows the request's user/service handles and independent atomic attempts. */
 declare class DatabaseTrace {
@@ -147,6 +197,8 @@ declare class DatabaseTrace {
 
 /** The slice of a SQL driver the engine uses. `Bun.sql` satisfies it. */
 interface SqlDriver {
+    /** Shared by every request and identity using this physical application pool. */
+    admission?: DatabaseAdmission;
     /** Optional reliable cancellation through a separate control connection. */
     cancelBackend?(pid: number, startedAt: string): Promise<void>;
     /** Run a parameterised statement. */
@@ -225,7 +277,7 @@ interface OpsContext {
     readonly commands?: boolean;
     readonly trace?: DatabaseTrace;
 }
-declare function createOps(tx: TxLike, context?: OpsContext): {
+declare function createOps(tx: TxLike | (() => TxLike | Promise<TxLike>), context?: OpsContext): {
     diagnostics(): DatabaseDiagnostics | null;
     query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
     insert(table: string, data: Row): Promise<Row>;
@@ -380,9 +432,6 @@ declare function createOps(tx: TxLike, context?: OpsContext): {
         with?: Record<string, unknown>;
     }): Promise<Row | null>;
     findById(table: string, id: string): Promise<Row | null>;
-    compileQuery(query: PreparedRead): CompiledRead;
-    readQuery(query: PreparedRead): Promise<Row[]>;
-    explainQuery(query: PreparedRead): Promise<unknown[]>;
     findMany(table: string, query?: Row, opts?: FindManyOptions): Promise<Row[]>;
     page(table: string, query?: Row, opts?: RawPageOptions): Promise<Page<Row>>;
     /**
@@ -557,6 +606,8 @@ declare function withTables<T extends ReturnType<typeof createOps>>(ops: T, sche
 interface RequestDatabase {
     /** What the engine injects as the request's `Database` singleton. */
     readonly client: DBClient;
+    /** @internal Core has finished its read-only authorization queries. */
+    authorizationComplete?(): void;
     /** Commit whatever was opened. Called once, after the handler returns. */
     commit(): Promise<void>;
     /** Roll back whatever was opened. Called once, when the handler throws. */
@@ -619,7 +670,7 @@ declare function createRequestDatabase(sql: SqlDriver, identity: {
     role: string;
     serviceRole: string;
     claimsJson: string;
-}, diagnostics?: DatabaseDiagnosticsOptions): RequestDatabase;
+}, diagnostics?: DatabaseDiagnosticsOptions, signal?: AbortSignal): RequestDatabase;
 
 /**
  * The two ways a stack refuses to boot — and they are two because their CURES
@@ -1100,6 +1151,8 @@ interface CreateAppOptions {
     logger?: Pick<Console, "info" | "warn" | "error" | "debug">;
 }
 interface App {
+    /** Core/operator observation of the shared physical pool's admission queue. */
+    readonly databasePressure?: ReturnType<typeof databaseAdmission>["snapshot"];
     handle: (req: Request) => Promise<Response>;
     routes: readonly RouteEntry[];
     config: EngineConfig;

package/dist/index.cjs

@@ -102,7 +102,6 @@ __export(src_exports, {
   __runWithRuntime: () => __runWithRuntime,
   __setRuntime: () => __setRuntime,
   assertNoOrphanEntryPoints: () => assertNoOrphanEntryPoints,
-  assertQueryManifest: () => assertQueryManifest,
   assertZeroArgConstructor: () => assertZeroArgConstructor,
   bigint: () => bigint,
   boolean: () => boolean,
@@ -117,10 +116,8 @@ __export(src_exports, {
   defineDefaultAuth: () => defineDefaultAuth,
   defineError: () => defineError,
   defineMiddleware: () => defineMiddleware,
-  defineQuery: () => defineQuery,
   defineSchema: () => defineSchema,
   defineTable: () => defineTable,
-  defineWorkload: () => defineWorkload,
   enumType: () => enumType,
   exprCtx: () => exprCtx,
   getErrorRegistry: () => getErrorRegistry,
@@ -156,7 +153,6 @@ __export(src_exports, {
   ownerOnly: () => ownerOnly,
   policy: () => policy,
   publicChannel: () => publicChannel,
-  queryManifest: () => queryManifest,
   raw: () => raw,
   recordThrows: () => recordThrows,
   resolveEffectiveAuth: () => resolveEffectiveAuth,
@@ -170,7 +166,7 @@ __export(src_exports, {
   vector: () => vector,
   webhooksOf: () => webhooksOf,
   withRetry: () => withRetry,
-  z: () => import_zod4.z
+  z: () => import_zod3.z
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -746,39 +742,6 @@ function translateRejection(err, builder) {
 }
 __name(translateRejection, "translateRejection");
 
-// src/db/workload.ts
-function defineWorkload(name, options) {
-  const result = {
-    name,
-    concurrency: options.concurrency,
-    queueLimit: options.queueLimit,
-    tenantConcurrency: options.tenantConcurrency ?? options.concurrency,
-    tenantQueueLimit: options.tenantQueueLimit ?? options.queueLimit,
-    queueTimeoutMs: options.queueTimeoutMs ?? 1e3,
-    tenantClaim: options.tenantClaim ?? "tenant_id"
-  };
-  validateWorkload(result);
-  return Object.freeze(result);
-}
-__name(defineWorkload, "defineWorkload");
-function validateWorkload(value) {
-  if (typeof value.name !== "string" || !/^[a-zA-Z][a-zA-Z0-9_.-]{0,63}$/.test(value.name)) throw new Error("workload name must be 1\u201364 letters/digits/dots/dashes");
-  for (const name of [
-    "concurrency",
-    "tenantConcurrency",
-    "queueLimit",
-    "tenantQueueLimit",
-    "queueTimeoutMs"
-  ]) {
-    const n = value[name], min = name.endsWith("Limit") ? 0 : 1;
-    const max = name === "queueTimeoutMs" ? 6e4 : name.endsWith("Limit") ? 1e4 : 1e3;
-    if (!Number.isInteger(n) || n < min || n > max) throw new Error(`workload ${name} must be an integer between ${min} and ${max}`);
-  }
-  if (value.tenantConcurrency > value.concurrency || value.tenantQueueLimit > value.queueLimit) throw new Error("workload tenant limits cannot exceed global limits");
-  if (typeof value.tenantClaim !== "string" || !/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/.test(value.tenantClaim)) throw new Error("workload tenantClaim must be a top-level claim name");
-}
-__name(validateWorkload, "validateWorkload");
-
 // src/db/transaction-options.ts
 function retryBudget(value) {
   const n = value ?? 0;
@@ -1237,7 +1200,9 @@ function makeTableProxy(ops, prefix) {
         // Older than this run, but the run rewrote this proxy for
         // `Database.schema(name).tables.*` and would have carried the gap onto
         // the new surface too.
-        updateMany: /* @__PURE__ */ __name((q) => ops().updateMany(name, q.where, q.set), "updateMany"),
+        updateMany: /* @__PURE__ */ __name((q) => ops().updateMany(name, q.where, q.set, q.returning === void 0 ? void 0 : {
+          returning: q.returning
+        }), "updateMany"),
         deleteMany: /* @__PURE__ */ __name((q) => ops().deleteMany(name, q.where), "deleteMany"),
         count: /* @__PURE__ */ __name((q) => ops().count(name, q?.where), "count"),
         search: /* @__PURE__ */ __name((params) => ops().search(name, params), "search"),
@@ -1257,9 +1222,6 @@ function makeTypedSurface(raw2) {
   const ops = {
     $query: /* @__PURE__ */ __name((sql, params) => raw2.query(sql, params), "$query"),
     $diagnostics: /* @__PURE__ */ __name(() => raw2.diagnostics(), "$diagnostics"),
-    $readQuery: /* @__PURE__ */ __name((query) => raw2.readQuery(query), "$readQuery"),
-    $compileQuery: /* @__PURE__ */ __name((query) => raw2.compileQuery(query), "$compileQuery"),
-    $explainQuery: /* @__PURE__ */ __name((query) => raw2.explainQuery(query), "$explainQuery"),
     $insert: /* @__PURE__ */ __name((table, data) => raw2.insert(table, data), "$insert"),
     $update: /* @__PURE__ */ __name((table, id, data) => raw2.update(table, id, data), "$update"),
     $delete: /* @__PURE__ */ __name((table, id) => raw2.delete(table, id), "$delete"),
@@ -3057,13 +3019,6 @@ function defineTable(name, input) {
 }
 __name(defineTable, "defineTable");
 var declaringSchemaOf = /* @__PURE__ */ new WeakMap();
-function declaredTableKey(table) {
-  const metadata = table[TABLE_META];
-  const schema = declaringSchemaOf.get(metadata);
-  if (schema === void 0) throw new Error(`defineQuery: table ${metadata.name} must belong to defineSchema before defining its query`);
-  return qualifiedTableKey(schema, metadata.name);
-}
-__name(declaredTableKey, "declaredTableKey");
 function resolveReferences(tables, schemaName) {
   for (const table of Object.values(tables)) {
     for (const [colName, builder] of Object.entries(table.columns)) {
@@ -3667,6 +3622,7 @@ var openai = {
 var SQLSTATE = Object.freeze({
   serializationFailure: "40001",
   deadlockDetected: "40P01",
+  queryCancelled: "57014",
   commandGuardFailed: "PBC01"
 });
 function isTransactionRollbackState(state) {
@@ -3891,9 +3847,6 @@ function makeTypedDB(schema, raw2) {
   const result = {
     tables,
     diagnostics: /* @__PURE__ */ __name(() => raw2.diagnostics(), "diagnostics"),
-    readQuery: /* @__PURE__ */ __name((query) => raw2.readQuery(query), "readQuery"),
-    compileQuery: /* @__PURE__ */ __name((query) => raw2.compileQuery(query), "compileQuery"),
-    explainQuery: /* @__PURE__ */ __name((query) => raw2.explainQuery(query), "explainQuery"),
     command(fn, options) {
       const builder = new TxPlanBuilder();
       const planTables = Object.fromEntries(Object.entries(schema.tables).map(([key, table]) => [
@@ -5723,188 +5676,7 @@ function getJobConfig(ctor, container) {
 __name(getJobConfig, "getJobConfig");
 
 // src/index.ts
-var import_zod4 = require("zod");
-
-// src/db/query.ts
 var import_zod3 = require("zod");
-var import_zod_to_openapi2 = require("@asteasolutions/zod-to-openapi");
-
-// src/db/query-contract.ts
-function queryColumnContract(column) {
-  const def = column && typeof column === "object" && "_def" in column ? column._def : column;
-  if (!def?.type) throw new Error("Query contract requires declared column types");
-  if (def.transform !== void 0 && def.codec === void 0) throw new Error("Query contracts require a named codec instead of a free-form column transform");
-  return {
-    type: def.type,
-    nullable: def.nullable === true,
-    ...def.codec === void 0 ? {} : {
-      codec: def.codec
-    },
-    ...def.enumValues === void 0 ? {} : {
-      enumValues: [
-        ...def.enumValues
-      ]
-    },
-    ...def.dimensions === void 0 ? {} : {
-      dimensions: def.dimensions
-    }
-  };
-}
-__name(queryColumnContract, "queryColumnContract");
-function stableContract(value) {
-  if (Array.isArray(value)) return `[${value.map(stableContract).join(",")}]`;
-  if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableContract(value[key])}`).join(",")}}`;
-  return JSON.stringify(value) ?? "null";
-}
-__name(stableContract, "stableContract");
-
-// src/db/query.ts
-(0, import_zod_to_openapi2.extendZodWithOpenApi)(import_zod3.z);
-function responseColumn(column, validator) {
-  const contract = queryColumnContract(column);
-  let schema;
-  if (validator) return validator;
-  if (contract.codec === "number") schema = import_zod3.z.number().finite();
-  else if (contract.codec === "decimal") schema = import_zod3.z.string();
-  else switch (contract.type) {
-    case "integer":
-      schema = import_zod3.z.number().int().min(-2147483648).max(2147483647);
-      break;
-    case "boolean":
-      schema = import_zod3.z.boolean();
-      break;
-    case "vector":
-      schema = import_zod3.z.array(import_zod3.z.number().finite());
-      break;
-    case "enum": {
-      const values = contract.enumValues;
-      if (!values?.length) throw new Error("Query response requires declared enum values");
-      schema = import_zod3.z.enum(values);
-      break;
-    }
-    case "uuid":
-    case "text":
-    case "timestamp":
-    case "numeric":
-    case "bigint":
-      schema = import_zod3.z.string();
-      break;
-    case "jsonb":
-      throw new Error("Query response requires a fields validator for a selected jsonb column: its TypeScript payload is erased at runtime");
-    default:
-      throw new Error(`Query response does not support column type ${contract.type}`);
-  }
-  return contract.nullable ? schema.nullable() : schema;
-}
-__name(responseColumn, "responseColumn");
-function defineQuery(name, options) {
-  if (typeof name !== "string" || !/^[A-Za-z][A-Za-z0-9_]{0,127}$/.test(name)) throw new Error("defineQuery requires a stable name of 1\u2013128 letters, digits or underscores");
-  const table = declaredTableKey(options.table);
-  const select = [
-    ...options.select
-  ];
-  if (!select.length || new Set(select).size !== select.length) throw new Error(`Query ${name}: select must be explicit, nonempty and distinct`);
-  const shape = {}, columns = {};
-  for (const key of select) {
-    if (!Object.hasOwn(options.table[TABLE_META].columns, key)) throw new Error(`Query ${name}: unknown column ${key}`);
-    columns[key] = queryColumnContract(options.table[key]);
-    shape[key] = responseColumn(options.table[key], options.fields?.[key]);
-  }
-  const response = import_zod3.z.array(import_zod3.z.object(shape).strict());
-  const queryInput = options.input, where = options.where, limit = options.limit;
-  const orderBy = options.orderBy === void 0 ? void 0 : JSON.parse(JSON.stringify(options.orderBy));
-  const prepare = /* @__PURE__ */ __name((input) => {
-    const parsed = queryInput.parse(input);
-    const filter = where === void 0 ? {} : where(parsed);
-    if (!filter || typeof filter !== "object" || Array.isArray(filter) || typeof filter.then === "function") {
-      throw new Error(`Query ${name}: where must return a synchronous filter object`);
-    }
-    const size = typeof limit === "function" ? limit(parsed) : limit;
-    if (limit !== void 0 && (typeof size !== "number" || !Number.isSafeInteger(size) || size < 0)) throw new Error(`Query ${name}: limit must produce a nonnegative safe integer`);
-    return {
-      name,
-      table,
-      columns: JSON.parse(JSON.stringify(columns)),
-      where: filter,
-      options: {
-        select: [
-          ...select
-        ],
-        ...orderBy === void 0 ? {} : {
-          orderBy: structuredClone(orderBy)
-        },
-        ...limit === void 0 ? {} : {
-          limit: size
-        }
-      }
-    };
-  }, "prepare");
-  const attach = /* @__PURE__ */ __name((schema) => {
-    const api = {
-      queryName: name,
-      input: queryInput,
-      prepare,
-      async run(database, input) {
-        const request = prepare(input);
-        const rows = await ("$readQuery" in database ? database.$readQuery(request) : database.readQuery(request));
-        return schema.parse(rows);
-      },
-      sql(database, input) {
-        const request = prepare(input);
-        return "$compileQuery" in database ? database.$compileQuery(request) : database.compileQuery(request);
-      },
-      explain(database, input) {
-        const request = prepare(input);
-        return "$explainQuery" in database ? database.$explainQuery(request) : database.explainQuery(request);
-      },
-      contract() {
-        const registry2 = new import_zod_to_openapi2.OpenAPIRegistry();
-        registry2.register(`${name}Input`, queryInput);
-        registry2.register(`${name}Response`, schema);
-        return JSON.parse(JSON.stringify({
-          name,
-          table,
-          select,
-          columns,
-          components: new import_zod_to_openapi2.OpenApiGeneratorV31(registry2.definitions).generateComponents().components
-        }));
-      }
-    };
-    for (const key of [
-      "min",
-      "max",
-      "length",
-      "describe",
-      "openapi"
-    ]) {
-      const modify = schema[key].bind(schema);
-      Object.defineProperty(schema, key, {
-        value: /* @__PURE__ */ __name((...args) => attach(modify(...args)), "value"),
-        configurable: true
-      });
-    }
-    return Object.assign(schema, api);
-  }, "attach");
-  return attach(response);
-}
-__name(defineQuery, "defineQuery");
-function queryManifest(queries) {
-  const sorted = [
-    ...queries
-  ].sort((a, b) => a.queryName.localeCompare(b.queryName));
-  if (new Set(sorted.map((query) => query.queryName)).size !== sorted.length) throw new Error("Query manifest contains duplicate names");
-  return JSON.parse(stableContract({
-    version: 1,
-    queries: sorted.map((query) => query.contract())
-  }));
-}
-__name(queryManifest, "queryManifest");
-function assertQueryManifest(queries, baseline) {
-  if (stableContract(queryManifest(queries)) !== stableContract(baseline)) {
-    throw new Error("Query contract drift: compare queryManifest() with the committed manifest and review the API/client changes before updating it");
-  }
-}
-__name(assertQueryManifest, "assertQueryManifest");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Auth,
@@ -5988,7 +5760,6 @@ __name(assertQueryManifest, "assertQueryManifest");
   __runWithRuntime,
   __setRuntime,
   assertNoOrphanEntryPoints,
-  assertQueryManifest,
   assertZeroArgConstructor,
   bigint,
   boolean,
@@ -6003,10 +5774,8 @@ __name(assertQueryManifest, "assertQueryManifest");
   defineDefaultAuth,
   defineError,
   defineMiddleware,
-  defineQuery,
   defineSchema,
   defineTable,
-  defineWorkload,
   enumType,
   exprCtx,
   getErrorRegistry,
@@ -6042,7 +5811,6 @@ __name(assertQueryManifest, "assertQueryManifest");
   ownerOnly,
   policy,
   publicChannel,
-  queryManifest,
   raw,
   recordThrows,
   resolveEffectiveAuth,