@palbase/backend 30.0.1 → 32.0.0

package/dist/index.cjs

@@ -1270,7 +1270,11 @@ function toSchemaJSON(schemas) {
 __name(toSchemaJSON, "toSchemaJSON");
 
 // src/runtime.ts
-var __requestALS = new import_node_async_hooks.AsyncLocalStorage();
+var REQUEST_ALS = /* @__PURE__ */ Symbol.for("palbase.backend.requestALS");
+var __requestALS = (() => {
+  const g = globalThis;
+  return g[REQUEST_ALS] ??= new import_node_async_hooks.AsyncLocalStorage();
+})();
 var runtime = null;
 function __setRuntime(services) {
   runtime = services;
@@ -1559,8 +1563,21 @@ var Flags = Object.assign({
    * the runtime proxy, so caching would leak one request's sibling into
    * another concurrent request. Mirrors `Database.asService()`.
    */
-  asService() {
+  $asService() {
     return rawFlags.asService();
+  },
+  /**
+   * The name this member carried before 31.0.0.
+   *
+   * It does NOT work silently. A retired member that quietly keeps returning
+   * is how a rename becomes a mystery: the old call site goes on compiling,
+   * the new name never spreads, and the two live side by side until somebody
+   * greps for one and misses half the codebase. `Database` made this split
+   * first (`$asService`), and this JSDoc promised "exactly like
+   * Database.$asService()" while the promise went unkept.
+   */
+  asService() {
+    throw new Error("Flags.asService() was renamed to Flags.$asService() in 31.0.0 \u2014 system members carry the `$` prefix, like Database.$asService().");
   }
 });
 var Realtime = makeServiceProxy("Realtime");
@@ -2103,7 +2120,7 @@ function buildFlagsClient(http, cfg) {
         return {
           data: null,
           error: {
-            message: "setOverride requires a signed-in user; use Flags.asService().setOverrideForUser(userId, key, value) for cross-user writes"
+            message: "setOverride requires a signed-in user; use Flags.$asService().setOverrideForUser(userId, key, value) for cross-user writes"
           },
           status: 400
         };
@@ -3295,6 +3312,23 @@ function isPalbaseExtension(name) {
 __name(isPalbaseExtension, "isPalbaseExtension");
 
 // src/db/columns.ts
+var CODECS = {
+  // Exact-precision column → JS number. Safe below 2^53; a value above it is
+  // not representable and the author wants `asDecimal()` instead.
+  number: {
+    fromDb: /* @__PURE__ */ __name((v) => Number(v), "fromDb"),
+    toDb: /* @__PURE__ */ __name((v) => String(v), "toDb"),
+    tsType: "number"
+  },
+  // Exact-precision column → the string Postgres sent. It exists so the
+  // DECLARATION is explicit: "this column is a decimal I handle as text",
+  // rather than the ABSENCE of a declaration meaning the same thing by default.
+  decimal: {
+    fromDb: /* @__PURE__ */ __name((v) => String(v), "fromDb"),
+    toDb: /* @__PURE__ */ __name((v) => String(v), "toDb"),
+    tsType: "string"
+  }
+};
 function refuseOnVector(def, modifier) {
   if (def.type === "vector") {
     throw new Error(`vector column: .${modifier}() is not supported (FR-002 \u2014 allowed: nullable()/notNull())`);
@@ -3498,6 +3532,35 @@ var ColumnBuilder = class _ColumnBuilder {
   * A transform is a PROJECTION, never a constraint: it lives only in this
   * process, so it can neither validate nor migrate what is stored.
   */
+  /**
+  * Surface this exact-precision column as a JS `number` (FR-001).
+  *
+  * `numeric`/`bigint` arrive as strings because a JS number cannot hold their
+  * full range — correct, and exactly why this exists: application code that
+  * does arithmetic on the column otherwise rewrites the same `Number(row.x)` /
+  * `String(v)` pair in every caller, and each rewrite is a place the two
+  * directions can drift apart.
+  */
+  asNumber() {
+    return this.withCodec("number", "asNumber");
+  }
+  /**
+  * Surface this exact-precision column as a `string` — the value Postgres
+  * sent, DECLARED rather than defaulted (FR-001).
+  */
+  asDecimal() {
+    return this.withCodec("decimal", "asDecimal");
+  }
+  withCodec(codec, method) {
+    if (this._def.type !== "bigint" && this._def.type !== "numeric") {
+      throw new Error(`${this._def.type} column: .${method}() is only available on bigint()/numeric() \u2014 those are the exact-precision types that surface as string.`);
+    }
+    if (this._def.transform !== void 0) {
+      throw new Error(`.${method}() and .transform() are two ways to say the same thing on one column \u2014 keep .${method}().`);
+    }
+    this._def.codec = codec;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
   transform(fns) {
     this._def.transform = fns;
     return new _ColumnBuilder(this._def.type, this._def);
@@ -3643,6 +3706,9 @@ __name(isDeclarationRefused, "isDeclarationRefused");
 
 // src/db/env-gen.ts
 function baseTsType(def) {
+  if (def.codec !== void 0 && def.codec in CODECS) {
+    return CODECS[def.codec].tsType;
+  }
   switch (def.type) {
     case "uuid":
     case "text":
@@ -3820,7 +3886,21 @@ function tableBlock(table, relations, indent) {
   ].join("\n");
 }
 __name(tableBlock, "tableBlock");
+function refuseFreeFormTransforms(schemas) {
+  for (const schema of schemas) {
+    for (const table of Object.values(schema.tables)) {
+      for (const [col2, builder] of Object.entries(table.columns)) {
+        const def = builder._def;
+        if (def.transform === void 0 || def.codec !== void 0) continue;
+        const where = qualifiedTableKey(schema.name, table.name);
+        throw new DeclarationRefused(`table "${where}" column "${col2}" declares .transform<T>(): its target type does not exist at runtime, so the generated types would say something the engine contradicts. Declare a named codec instead \u2014 .asNumber() for a JS number, .asDecimal() for the exact string.`);
+      }
+    }
+  }
+}
+__name(refuseFreeFormTransforms, "refuseFreeFormTransforms");
 function makeEnvDts(schemas) {
+  refuseFreeFormTransforms(schemas);
   const relations = buildRelations(schemas);
   const publicSchema = schemas.find((s) => s.name === "public");
   const others = schemas.filter((s) => s.name !== "public");