@vibeorm/runtime 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/index.js

@@ -11,7 +11,7 @@ function toSqlExecutor(params) {
   };
 }
 // packages/runtime/src/model-meta.ts
-import { VibeError, isEnumType } from "@vibeorm/schema";
+import { VibeError, isEnumType, validateComputedConfig } from "@vibeorm/schema";
 function toClientName(params) {
   const { name } = params;
   if (name.length === 0)
@@ -165,6 +165,11 @@ function buildModelMeta(params) {
     if (index.kind === "unique")
       addCompound(index.fields.map((entry) => entry.name));
   }
+  const computedSpecs = params.computed;
+  const computed = computedSpecs === undefined || Object.keys(computedSpecs).length === 0 ? null : new Map(Object.entries(computedSpecs).map(([name, spec]) => [
+    name,
+    { name, type: spec.type, needs: spec.needs, compute: spec.compute }
+  ]));
   return {
     name: model.name,
     clientName: toClientName({ name: model.name }),
@@ -177,12 +182,19 @@ function buildModelMeta(params) {
     compoundUniques,
     relations: model.relations,
     relationByName: new Map(model.relations.map((relation) => [relation.name, relation])),
-    isView: model.isView
+    isView: model.isView,
+    computed
   };
 }
 function buildRuntimeMeta(params) {
-  const { schema } = params;
-  const models = schema.models.map((model) => buildModelMeta({ model }));
+  const { schema, computed } = params;
+  if (computed !== undefined && Object.keys(computed).length > 0) {
+    validateComputedConfig({ schema, computed });
+  }
+  const models = schema.models.map((model) => {
+    const specs = computed?.[model.name];
+    return buildModelMeta({ model, ...specs === undefined ? {} : { computed: specs } });
+  });
   const modelByName = new Map;
   for (const model of models) {
     modelByName.set(model.name, model);
@@ -210,6 +222,13 @@ function getFieldMeta(params) {
   const { model, field, context } = params;
   const found = model.fieldByName.get(field);
   if (found === undefined) {
+    if (model.computed !== null && model.computed.has(field)) {
+      throw new VibeError({
+        code: "VIBE_VALIDATION",
+        message: `"${field}" on model "${model.name}" is a computed field \u2014 computed fields appear in results (select/omit) only, not in ${context}`,
+        meta: { model: model.name, field, context, computed: true }
+      });
+    }
     if (model.relationByName.has(field)) {
       throw new VibeError({
         code: "VIBE_VALIDATION",
@@ -678,6 +697,15 @@ function compileChildSelect(params) {
       continue;
     if (name === "_count" || model.relationByName.has(name))
       continue;
+    if (model.computed !== null && model.computed.has(name)) {
+      if (value !== true) {
+        throw validationError({
+          message: `select.${name} must be true or false on model "${model.name}"`,
+          meta: { model: model.name, field: name }
+        });
+      }
+      continue;
+    }
     const field = model.fieldByName.get(name);
     if (field === undefined) {
       throw validationError({
@@ -719,6 +747,8 @@ function compileChildOmit(params) {
         meta: { model: model.name, relation, field: name }
       });
     }
+    if (model.computed !== null && model.computed.has(name))
+      continue;
     if (!model.fieldByName.has(name)) {
       throw validationError({
         message: `unknown field "${name}" on model "${model.name}" in omit`,
@@ -827,6 +857,19 @@ function resolveNode(params) {
     include: raw.include
   });
   const select = raw.select !== undefined ? compileChildSelect({ model: link.target, select: raw.select }) : raw.omit !== undefined ? compileChildOmit({ model: link.target, omit: raw.omit, relation: relation.name }) : null;
+  const targetComputed = link.target.computed;
+  let computed = null;
+  if (targetComputed !== null) {
+    if (raw.select !== undefined) {
+      const names = Object.entries(raw.select).filter(([name, value]) => targetComputed.has(name) && value === true).map(([name]) => name);
+      computed = names.length === 0 ? null : names;
+    } else if (raw.omit !== undefined) {
+      const names = [...targetComputed.keys()].filter((name) => raw.omit[name] !== true);
+      computed = names.length === 0 ? null : names;
+    } else {
+      computed = [...targetComputed.keys()];
+    }
+  }
   let projected = null;
   const strip = [];
   if (select !== null) {
@@ -837,6 +880,13 @@ function resolveNode(params) {
         additions.add(name);
       }
     }
+    if (computed !== null && targetComputed !== null) {
+      for (const name of computed) {
+        for (const need of targetComputed.get(name)?.needs ?? []) {
+          additions.add(need);
+        }
+      }
+    }
     for (const name of additions) {
       if (!fetch.includes(name)) {
         fetch.push(name);
@@ -848,7 +898,7 @@ function resolveNode(params) {
   return {
     name: relation.name,
     link,
-    args: { where, orderBy: raw.orderBy, take, skip, select, projected, strip, nested }
+    args: { where, orderBy: raw.orderBy, take, skip, select, projected, strip, computed, nested }
   };
 }
 function resolveRelationSelection(params) {
@@ -1807,6 +1857,8 @@ function compileSelect(params) {
       continue;
     if (name === "_count" || model.relationByName.has(name))
       continue;
+    if (model.computed !== null && model.computed.has(name))
+      continue;
     if (value !== true) {
       throw validationError2({
         message: `select.${name} must be true or false on model "${model.name}"`,
@@ -1823,6 +1875,38 @@ function compileSelect(params) {
   }
   return names;
 }
+function resolveComputedSelection(params) {
+  const { model, args, aggregating } = params;
+  const specs = model.computed;
+  if (specs === null || aggregating)
+    return null;
+  if (isPlainObject2(args.select)) {
+    const names = [];
+    for (const [name, value] of Object.entries(args.select)) {
+      if (!specs.has(name) || value === undefined || value === false)
+        continue;
+      if (value !== true) {
+        throw validationError2({
+          message: `select.${name} must be true or false on model "${model.name}"`,
+          meta: { model: model.name, field: name }
+        });
+      }
+      names.push(name);
+    }
+    return names.length === 0 ? null : names;
+  }
+  if (isPlainObject2(args.omit)) {
+    const names = [];
+    for (const name of specs.keys()) {
+      const value = args.omit[name];
+      if (value === true)
+        continue;
+      names.push(name);
+    }
+    return names.length === 0 ? null : names;
+  }
+  return [...specs.keys()];
+}
 var fullProjectionCache = new WeakMap;
 function projectionColumns(params) {
   const { model, selectedFields, table } = params;
@@ -2567,6 +2651,8 @@ function compileOmit(params) {
         meta: { model: model.name, field: name }
       });
     }
+    if (model.computed !== null && model.computed.has(name))
+      continue;
     omitted.add(getFieldMeta({ model, field: name, context: "omit" }).name);
   }
   const kept = model.fields.filter((field) => !omitted.has(field.name)).map((field) => field.name);
@@ -2907,7 +2993,8 @@ function resolveResultShape(params) {
   const { meta, model, method, args } = params;
   assertArgs({ method, args, model });
   const relations = resolveRelationSelection({ meta, model, select: args.select, include: args.include });
-  const scalarSelect = args.select === undefined ? null : compileSelect({ model, select: args.select, allowEmpty: relations !== null });
+  const computed = resolveComputedSelection({ model, args, aggregating: false });
+  const scalarSelect = args.select === undefined ? null : compileSelect({ model, select: args.select, allowEmpty: relations !== null || computed !== null });
   const resultFields = scalarSelect === null ? null : [...scalarSelect];
   if (relations !== null && resultFields !== null) {
     for (const node of relations.relations)
@@ -2915,7 +3002,11 @@ function resolveResultShape(params) {
     if (relations.counts.length > 0)
       resultFields.push("_count");
   }
-  return { relations, resultFields };
+  if (computed !== null && resultFields !== null) {
+    for (const name of computed)
+      resultFields.push(name);
+  }
+  return { relations, resultFields, computed };
 }
 function buildQuery(params) {
   const { meta, dialect, method } = params;
@@ -2951,7 +3042,8 @@ function buildQuery(params) {
       meta: { model: model.name, method }
     });
   }
-  const scalarSelect = aggregating ? null : args.select !== undefined ? compileSelect({ model, select: args.select, allowEmpty: relations !== null }) : args.omit !== undefined ? compileOmit({ model, omit: args.omit }) : null;
+  const computedSelection = resolveComputedSelection({ model, args, aggregating });
+  const scalarSelect = aggregating ? null : args.select !== undefined ? compileSelect({ model, select: args.select, allowEmpty: relations !== null || computedSelection !== null }) : args.omit !== undefined ? compileOmit({ model, omit: args.omit }) : null;
   let selectedFields = scalarSelect === null ? null : [...scalarSelect];
   let resultFields = scalarSelect === null ? null : [...scalarSelect];
   if (relations !== null && resultFields !== null) {
@@ -2960,6 +3052,10 @@ function buildQuery(params) {
     if (relations.counts.length > 0)
       resultFields.push("_count");
   }
+  if (computedSelection !== null && resultFields !== null) {
+    for (const name of computedSelection)
+      resultFields.push(name);
+  }
   if (relations !== null && selectedFields !== null) {
     for (const name of requiredParentFields({ meta, model, selection: relations })) {
       if (!selectedFields.includes(name))
@@ -2972,12 +3068,21 @@ function buildQuery(params) {
         selectedFields.push(field.name);
     }
   }
+  if (computedSelection !== null && selectedFields !== null && model.computed !== null) {
+    for (const name of computedSelection) {
+      for (const need of model.computed.get(name)?.needs ?? []) {
+        if (!selectedFields.includes(need))
+          selectedFields.push(need);
+      }
+    }
+  }
   const selectArg = args.select === undefined || aggregating ? null : args.select;
   const base = {
     method,
     model,
     selectedFields,
     resultFields,
+    computed: computedSelection,
     relations,
     relationStrategy,
     takeApplied: args.take !== undefined,
@@ -3352,7 +3457,68 @@ function buildQuery(params) {
   }
 }
 // packages/runtime/src/relation-loader.ts
+import { VibeError as VibeError6 } from "@vibeorm/schema";
+
+// packages/runtime/src/computed.ts
 import { VibeError as VibeError5 } from "@vibeorm/schema";
+function sameNeeds(a, b) {
+  if (a.length !== b.length)
+    return false;
+  const left = [...a].sort();
+  const right = [...b].sort();
+  return left.every((value, index) => value === right[index]);
+}
+function assertComputedManifest(params) {
+  const { manifest } = params;
+  const specs = params.specs ?? {};
+  const live = new Map;
+  for (const [model, fields] of Object.entries(specs)) {
+    for (const [field, spec] of Object.entries(fields)) {
+      live.set(`${model}.${field}`, { type: spec.type, needs: spec.needs });
+    }
+  }
+  const problems = [];
+  for (const baked of manifest) {
+    const key = `${baked.model}.${baked.field}`;
+    const current = live.get(key);
+    if (current === undefined) {
+      problems.push(`"${key}" was baked into the client but is missing from the computed config`);
+      continue;
+    }
+    if (current.type !== baked.type) {
+      problems.push(`"${key}" type changed (generated ${JSON.stringify(baked.type)}, live ${JSON.stringify(current.type)})`);
+    } else if (!sameNeeds(current.needs, baked.needs)) {
+      problems.push(`"${key}" needs changed since generate`);
+    }
+    live.delete(key);
+  }
+  for (const key of live.keys()) {
+    problems.push(`"${key}" is configured but missing from the generated client`);
+  }
+  if (problems.length > 0) {
+    throw new VibeError5({
+      code: "VIBE_STALE_CLIENT",
+      message: `computed-field config changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
+      meta: { problems }
+    });
+  }
+}
+function applyComputedFields(params) {
+  const { model, rows, names } = params;
+  const specs = model.computed;
+  if (names === null || names.length === 0 || specs === null || rows.length === 0)
+    return;
+  for (const row of rows) {
+    for (const name of names) {
+      const spec = specs.get(name);
+      if (spec === undefined)
+        continue;
+      row[name] = spec.compute(row);
+    }
+  }
+}
+
+// packages/runtime/src/relation-loader.ts
 var COUNT_VALUE_ALIAS = "__vibe_count";
 function distinctKeys(params) {
   const { rows, field } = params;
@@ -3494,7 +3660,7 @@ async function loadManyToMany(params) {
   const link = node.link;
   const join = link.join;
   if (join === null) {
-    throw new VibeError5({
+    throw new VibeError6({
       code: "VIBE_INTERNAL",
       message: `manyToMany relation "${node.name}" resolved without join-table wiring`
     });
@@ -3643,6 +3809,9 @@ async function loadNode(params) {
 }
 async function finishNode(params) {
   const { ctx, node, kept } = params;
+  if (node.args.computed !== null && kept.length > 0) {
+    applyComputedFields({ model: node.link.target, rows: kept, names: node.args.computed });
+  }
   if (node.args.nested !== null && kept.length > 0) {
     await attachRelations({
       dialect: ctx.dialect,
@@ -3689,7 +3858,7 @@ async function attachLateralRelations(params) {
         try {
           parsed = JSON.parse(raw);
         } catch (cause) {
-          throw new VibeError5({
+          throw new VibeError6({
             code: "VIBE_INTERNAL",
             message: `relation column "${column}" returned text that is not valid JSON`,
             meta: { relation: node.name },
@@ -3726,12 +3895,12 @@ async function attachLateralRelations(params) {
   await loadCounts({ ctx, model, rows, counts: selection.counts });
 }
 // packages/runtime/src/nested-writes.ts
-import { VibeError as VibeError6 } from "@vibeorm/schema";
+import { VibeError as VibeError7 } from "@vibeorm/schema";
 function validationError3(params) {
-  return new VibeError6({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError7({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function notFound(params) {
-  return new VibeError6({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
+  return new VibeError7({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
 }
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
@@ -4561,7 +4730,7 @@ async function updateWithNested(params) {
   });
 }
 // packages/runtime/src/extensions.ts
-import { VibeError as VibeError7, extensionManifestEntry } from "@vibeorm/schema";
+import { VibeError as VibeError8, extensionManifestEntry } from "@vibeorm/schema";
 function assertExtensionManifest(params) {
   const { manifest } = params;
   const instances = params.instances ?? [];
@@ -4584,7 +4753,7 @@ function assertExtensionManifest(params) {
     problems.push(`"${name}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError7({
+    throw new VibeError8({
       code: "VIBE_STALE_CLIENT",
       message: `extension list changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { manifest, problems }
@@ -4599,7 +4768,7 @@ function buildExtensionOperatorMap(params) {
     for (const operator of extension.sql?.whereOperators ?? []) {
       const existing = owner.get(operator.name);
       if (existing !== undefined) {
-        throw new VibeError7({
+        throw new VibeError8({
           code: "VIBE_CONFIG",
           message: `where operator "${operator.name}" is claimed by both "${existing}" and "${extension.name}"`,
           meta: { operator: operator.name }
@@ -4615,7 +4784,7 @@ function buildExtensionOperatorMap(params) {
           options: extension.options
         });
         if ("error" in compiled) {
-          throw new VibeError7({
+          throw new VibeError8({
             code: "VIBE_VALIDATION",
             message: `"${operator.name}" on ${model}.${field}: ${compiled.error}`,
             meta: { model, field, operator: operator.name, extension: extension.name }
@@ -4647,9 +4816,9 @@ function buildConnectHooks(params) {
   return hooks;
 }
 // packages/runtime/src/views.ts
-import { VibeError as VibeError8 } from "@vibeorm/schema";
+import { VibeError as VibeError9 } from "@vibeorm/schema";
 function validationError4(params) {
-  return new VibeError8({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError9({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 
 class ViewResult {
@@ -5001,7 +5170,7 @@ function createView(params) {
   for (const [clientName, mask] of resolved) {
     const delegate = models[clientName];
     if (delegate === undefined) {
-      throw new VibeError8({
+      throw new VibeError9({
         code: "VIBE_INTERNAL",
         message: `view "${name}": no delegate for model "${mask.model.name}"`,
         meta: { view: name, model: mask.model.name }
@@ -5017,7 +5186,7 @@ function attachDefineView(params) {
   Object.defineProperty(client, "$defineView", { value, enumerable: true });
 }
 // packages/runtime/src/client.ts
-import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 import { ParamCollector, getSqlDialect } from "@vibeorm/sql";
 
 // packages/runtime/src/render-cache.ts
@@ -5437,7 +5606,7 @@ function renderStatementCached(params) {
 // packages/runtime/src/client.ts
 function notFound2(params) {
   const { model, method } = params;
-  return new VibeError9({
+  return new VibeError10({
     code: "VIBE_NOT_FOUND",
     message: `no ${model} record matched the where clause of ${method}()`,
     meta: { model, method }
@@ -5445,7 +5614,7 @@ function notFound2(params) {
 }
 function viewIsReadOnly(params) {
   const { model, method } = params;
-  return new VibeError9({
+  return new VibeError10({
     code: "VIBE_VALIDATION",
     message: `${model} is a view \u2014 ${method}() is not available on views (they are read-only); write to the underlying table instead`,
     meta: { model, method }
@@ -5574,7 +5743,7 @@ class QueryPromise extends Promise {
   }
   claim() {
     if (this.started) {
-      throw new VibeError9({
+      throw new VibeError10({
         code: "VIBE_VALIDATION",
         message: "$transaction([...]) needs operations that have not dispatched \u2014 pass delegate calls in the same tick they are created (this one was awaited or created earlier and already executed outside the transaction)"
       });
@@ -5718,7 +5887,7 @@ async function insertedKeyWhere(params) {
   });
   const id = result.rows[0]?.id;
   if (id === undefined || id === null) {
-    throw new VibeError9({
+    throw new VibeError10({
       code: "VIBE_INTERNAL",
       message: `could not read back the generated key for ${source.model.name}`,
       meta: { model: source.model.name }
@@ -5895,6 +6064,9 @@ async function finalizeRows(params) {
       });
     }
   }
+  if (shape.computed !== null && rows.length > 0) {
+    applyComputedFields({ model, rows, names: shape.computed });
+  }
   if (shape.resultFields === null)
     return rows;
   return rows.map((row) => project({ row, fields: shape.resultFields }));
@@ -5968,7 +6140,8 @@ function createDelegate(params) {
   const shapeOf = (built) => ({
     relations: built.relations,
     resultFields: built.resultFields,
-    relationStrategy: built.relationStrategy
+    relationStrategy: built.relationStrategy,
+    computed: built.computed
   });
   const findMany = async (target, args) => {
     const built = plan({ engine: target, model, method: "findMany", args });
@@ -6061,7 +6234,7 @@ function createDelegate(params) {
   const upsert = async (target, args) => {
     const modelMeta = getModelMeta({ meta: target.meta, model });
     if (hasNestedWrites({ model: modelMeta, data: args.create }) || hasNestedWrites({ model: modelMeta, data: args.update })) {
-      throw new VibeError9({
+      throw new VibeError10({
         code: "VIBE_VALIDATION",
         message: `nested writes are not supported inside upsert arms on ${modelMeta.name} \u2014 use create()/update() with nested data`,
         meta: { model: modelMeta.name }
@@ -6216,7 +6389,7 @@ function buildClient(params) {
     let claimError = null;
     for (const operation of operations) {
       if (!(operation instanceof QueryPromise)) {
-        claimError = new VibeError9({
+        claimError = new VibeError10({
           code: "VIBE_VALIDATION",
           message: "$transaction([...]) takes query promises from model delegate calls \u2014 a foreign promise is already running and cannot join the transaction"
         });
@@ -6255,7 +6428,7 @@ function buildClient(params) {
     $models: models,
     $on: (event, listener) => {
       if (event !== "query") {
-        throw new VibeError9({
+        throw new VibeError10({
           code: "VIBE_VALIDATION",
           message: `unknown client event "${String(event)}" \u2014 supported: "query"`,
           meta: { event }
@@ -6318,7 +6491,7 @@ function makeMountContext(params) {
     compileWhere: ({ where, model: modelName, qualify }) => {
       const target = modelName === undefined ? model : getModelMeta({ meta: engine.meta, model: modelName });
       if (target === null) {
-        throw new VibeError9({
+        throw new VibeError10({
           code: "VIBE_INTERNAL",
           message: `extension "${extension}" compiled a where with no model in scope`,
           meta: { extension }
@@ -6344,7 +6517,7 @@ function attachExtensionMounts(params) {
       const model = getModelMeta({ meta: engine.meta, model: mount.model ?? "" });
       const delegate = models[model.name];
       if (delegate === undefined || mount.property in delegate) {
-        throw new VibeError9({
+        throw new VibeError10({
           code: "VIBE_CONFIG",
           message: `extension "${mount.extension}" cannot mount "${mount.property}" on ${model.name} \u2014 the name is taken`,
           meta: { extension: mount.extension, model: model.name, property: mount.property }
@@ -6355,7 +6528,7 @@ function attachExtensionMounts(params) {
       continue;
     }
     if (!mount.property.startsWith("$") || mount.property in client) {
-      throw new VibeError9({
+      throw new VibeError10({
         code: "VIBE_CONFIG",
         message: `extension "${mount.extension}" cannot mount client property "${mount.property}" \u2014 root mounts are $-prefixed and must not collide`,
         meta: { extension: mount.extension, property: mount.property }
@@ -6366,15 +6539,28 @@ function attachExtensionMounts(params) {
   }
 }
 function createClient(params) {
-  const { schema, adapter, options, extensions } = params;
+  const { schema, adapter, options, extensions, computed } = params;
   const dialectName = adapter.dialect;
   if (extensions?.manifest !== undefined) {
     assertExtensionManifest({ manifest: extensions.manifest, instances: extensions.instances });
   }
+  if (computed?.manifest !== undefined) {
+    assertComputedManifest({ manifest: computed.manifest, specs: computed.specs });
+  }
+  if (computed === undefined && options !== undefined && options["computed"] !== undefined) {
+    throw new VibeError10({
+      code: "VIBE_CONFIG",
+      message: "this client was generated without computed fields \u2014 declare them in vibeorm.config.ts and re-run vibeorm generate",
+      meta: {}
+    });
+  }
   const instances = extensions?.instances ?? [];
   const operatorMap = instances.length === 0 ? null : buildExtensionOperatorMap({ instances, dialect: dialectName, provider: adapter.provider });
   const connectHooks = instances.length === 0 ? [] : buildConnectHooks({ instances, dialect: dialectName, provider: adapter.provider });
-  const baseMeta = buildRuntimeMeta({ schema });
+  const baseMeta = buildRuntimeMeta({
+    schema,
+    ...computed?.specs === undefined ? {} : { computed: computed.specs }
+  });
   const meta = operatorMap === null ? baseMeta : { ...baseMeta, extensionOperators: operatorMap };
   return buildClient({
     engine: {
@@ -6426,6 +6612,8 @@ export {
   attachLateralRelations,
   attachDefineView,
   assertExtensionManifest,
+  assertComputedManifest,
+  applyComputedFields,
   ViewResult,
   SQLITE_CODECS,
   POSTGRES_CODECS,
@@ -6434,4 +6622,4 @@ export {
   COUNT_ALIAS
 };
 
-//# debugId=E85807B9EEEC573F64756E2164756E21
+//# debugId=D09B25CE72AA9DC064756E2164756E21