@vibeorm/runtime 1.3.0 → 2.0.0-alpha.2

package/dist/relation-plan.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Relation RESOLUTION: `select`/`include` args → a validated relation tree,
+ * plus the structural link (FK fields, join table) each relation loads through.
+ *
+ * Pure structure — no SQL, no execution. The query builder consumes this to
+ * gate strategies and augment projections at build time (the earliest knowable
+ * moment); the relation loader consumes it to run and stitch.
+ *
+ * v1 semantics carried:
+ * - `select: { rel: … }` and `include: { rel: … }` both load; `include` wins
+ *   when both name the same relation.
+ * - `_count` uses the v1 shape: `include._count: true | { select: { rel: true } }`
+ *   (or under `select`), counts LIST relations only, and supports no `where`.
+ * - Implicit many-to-many resolves through the ONE shared join-table rule
+ *   (`implicitJoinTable` in @vibeorm/schema) — never re-derived here.
+ */
+import type { RelationIR } from "@vibeorm/schema";
+import type { FieldMeta, ModelMeta, RuntimeMeta } from "./model-meta.ts";
+/** How a relation is physically wired. */
+export type RelationKind = 
+/** Children hold the FK (`oneToMany`) — batch `WHERE fk IN (parents)`. */
+"toManyFk"
+/** THIS model holds the FK (`manyToOne` / owning `oneToOne`). */
+ | "toOneOwner"
+/** The other side holds the FK (non-owning `oneToOne`). */
+ | "toOneInverse"
+/** Implicit join table (`manyToMany`). */
+ | "manyToMany";
+/** The resolved physical link for one relation. */
+export type RelationLink = {
+    readonly kind: RelationKind;
+    readonly relation: RelationIR;
+    readonly target: ModelMeta;
+    /** Field on the PARENT whose values correlate the two sides. */
+    readonly parentKey: FieldMeta;
+    /** Field on the CHILD whose values match `parentKey`'s. */
+    readonly childKey: FieldMeta;
+    /** Join-table wiring; `null` unless kind is `manyToMany`. */
+    readonly join: {
+        readonly tableName: string;
+        readonly parentColumn: "A" | "B";
+        readonly childColumn: "A" | "B";
+    } | null;
+};
+/** Nested args for one relation to load, validated. */
+export type RelationArgs = {
+    readonly where: Record<string, unknown> | undefined;
+    readonly orderBy: unknown;
+    readonly take: number | undefined;
+    readonly skip: number | undefined;
+    /** Child scalar fields the CALLER asked for, or `null` for all scalars. */
+    readonly select: readonly string[] | null;
+    /** SQL projection: `select` plus stitching keys — what the child statement fetches. */
+    readonly projected: readonly string[] | null;
+    /** Fields in `projected` the caller did NOT ask for — deleted after stitching. */
+    readonly strip: readonly string[];
+    /** Computed fields to attach to loaded children, or `null` — resolved like the top level. */
+    readonly computed: readonly string[] | null;
+    /** Deeper relation levels under this one. */
+    readonly nested: RelationSelection | null;
+};
+export type RelationTreeNode = {
+    /** Relation field name on the parent (`posts`). */
+    readonly name: string;
+    readonly link: RelationLink;
+    readonly args: RelationArgs;
+};
+/** Everything relation-shaped one query level asked for. */
+export type RelationSelection = {
+    readonly relations: readonly RelationTreeNode[];
+    /** List-relation names to count into `_count`. */
+    readonly counts: readonly string[];
+};
+/** Resolve how one relation is physically wired. */
+export declare function resolveRelationLink(params: {
+    meta: RuntimeMeta;
+    model: ModelMeta;
+    relation: RelationIR;
+}): RelationLink;
+/**
+ * The parent-side fields a selection needs for stitching: each relation's
+ * `parentKey`, and each counted relation's `parentKey`.
+ */
+export declare function requiredParentFields(params: {
+    meta: RuntimeMeta;
+    model: ModelMeta;
+    selection: RelationSelection;
+}): string[];
+/**
+ * Resolve everything relation-shaped in one level's `select`/`include`.
+ * Returns `null` when neither names a relation or `_count`.
+ *
+ * Scalar keys in `select` are ignored here (the query builder projects them);
+ * every key in `include` must be a relation or `_count` — anything else is a
+ * loud validation error.
+ */
+export declare function resolveRelationSelection(params: {
+    meta: RuntimeMeta;
+    model: ModelMeta;
+    select: unknown;
+    include: unknown;
+}): RelationSelection | null;
+//# sourceMappingURL=relation-plan.d.ts.map

package/dist/relation-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation-plan.d.ts","sourceRoot":"","sources":["../src/relation-plan.ts"],"names":[],"mappings":"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"}

package/dist/render-cache.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The compiled-query cache — §9's "query-shape cache (structural hash → SQL
+ * skeleton)", constitution rule 8 (perf) under rule 3's constraint: the SQL
+ * text is ALWAYS the renderer's, byte-identical — this module never builds SQL.
+ *
+ * How it works: a statement AST is walked ONCE, producing (a) a structural key
+ * covering everything that affects the rendered text — kinds, identifiers,
+ * operators, flags, literal LIMIT/OFFSET, arity where a dialect expands
+ * placeholders per element — and (b) the parameter values in exactly the
+ * renderer's collection order. A key hit reuses the cached text with the fresh
+ * values; a miss renders for real and caches the text.
+ *
+ * SAFETY: the walk mirrors @vibeorm/sql's render traversal. Two guards keep a
+ * divergence from ever mis-binding parameters:
+ *   1. every MISS cross-checks the walked values against the renderer's
+ *      collected values (element-wise); a mismatch poisons the key so that
+ *      shape renders uncached forever, and
+ *   2. constructs with dialect-conditional value branching that is not worth
+ *      mirroring (jsonFilter) are declared uncacheable outright.
+ * The cache is invalidation-free by construction: the key IS the shape, and
+ * equal shapes render equal text (shape-purity). Statement ASTs are treated as
+ * immutable by the whole runtime, so cached texts can never go stale.
+ */
+import type { RenderedQuery, SqlDialect, SqlStatement } from "@vibeorm/sql";
+type CachedText = {
+    readonly text: string;
+    readonly returning: "native" | "omitted" | "none";
+};
+/** `null` = poisoned: this shape verified unsafe once — never cache it. */
+type CacheSlot = CachedText | null;
+/** One per client (dialect-stable); shared across its transaction clients. */
+export declare class StatementRenderCache {
+    private readonly entries;
+    get(key: string): CacheSlot | undefined;
+    set(key: string, slot: CacheSlot): void;
+}
+/**
+ * Render through the shape cache: hit = cached text + freshly walked values;
+ * miss = real render, cross-checked against the walk before caching. Anything
+ * uncacheable (or a verification failure — poisoned) renders directly.
+ */
+export declare function renderStatementCached(params: {
+    dialect: SqlDialect;
+    statement: SqlStatement;
+    cache: StatementRenderCache;
+}): RenderedQuery;
+export {};
+//# sourceMappingURL=render-cache.d.ts.map

package/dist/render-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-cache.d.ts","sourceRoot":"","sources":["../src/render-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAMV,aAAa,EAEb,UAAU,EAEV,YAAY,EAGb,MAAM,cAAc,CAAC;AAItB,KAAK,UAAU,GAAG;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;CACnD,CAAC;AAEF,2EAA2E;AAC3E,KAAK,SAAS,GAAG,UAAU,GAAG,IAAI,CAAC;AAInC,8EAA8E;AAC9E,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAE7D,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIvC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;CAMxC;AA2aD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,UAAU,CAAC;IACpB,SAAS,EAAE,YAAY,CAAC;IACxB,KAAK,EAAE,oBAAoB,CAAC;CAC7B,GAAG,aAAa,CAoBhB"}

package/dist/views.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Field-masking views — the v1 `db.defineView()` surface ported to v2
+ * (board #11), renamed `$defineView` per v2's $-prefixed client-name rule.
+ *
+ * A view is a READ-ONLY scoped client over the models named in its definition.
+ * Rows come back as `ViewResult` instances that expose only the definition's
+ * fields; `reveal: { field: true }` makes an extra field readable as a
+ * property while `JSON.stringify` still excludes it, and `$unsafe()` returns
+ * everything. Relations load normally: when the related model is ALSO in the
+ * definition its rows are masked recursively; when it is not, they pass
+ * through untouched (v1 semantics).
+ *
+ * Isolated by design: this module wraps the public delegate surface
+ * (`client.$models`) and never reaches into the query builder — the same SQL
+ * runs, the ARGS are rewritten (definition fields become a `select`) and the
+ * RESULT objects are wrapped.
+ *
+ * v1 → v2 deltas (documented in apps/tests/parity-fragments/views.md):
+ *  - `defineView` → `$defineView`; errors are `VibeError` codes, not strings.
+ *  - The definition is validated eagerly (unknown model / unknown field /
+ *    empty field set throw `VIBE_VALIDATION` at definition time).
+ *  - Write verbs exist on the view delegate but throw `VIBE_VALIDATION`
+ *    (mirroring v2's database-view read-only contract) — v1 left them
+ *    `undefined`.
+ *  - A nested `include` under a masked relation stays masked (v1 dropped the
+ *    restriction one level down); `omit` on a view query is refused loudly
+ *    (v1 stripped it silently).
+ */
+import type { ClientRow, ModelDelegate } from "./client.ts";
+import type { RuntimeMeta } from "./model-meta.ts";
+/**
+ * A view definition: client-name model keys → the set of visible fields.
+ * Example: `{ user: { id: true, name: true }, post: { id: true, title: true } }`.
+ */
+export type ViewDefinition = Record<string, Record<string, boolean | undefined>>;
+/** The read surface of one model under a view — writes throw `VIBE_VALIDATION`. */
+export type ViewModelDelegate = {
+    readonly findMany: (args?: ClientRow) => Promise<ViewResult[]>;
+    readonly findFirst: (args?: ClientRow) => Promise<ViewResult | null>;
+    readonly findFirstOrThrow: (args?: ClientRow) => Promise<ViewResult>;
+    readonly findUnique: (args: ClientRow) => Promise<ViewResult | null>;
+    readonly findUniqueOrThrow: (args: ClientRow) => Promise<ViewResult>;
+    readonly count: (args?: ClientRow) => Promise<number | Record<string, number>>;
+    readonly aggregate: (args: ClientRow) => Promise<ClientRow>;
+    readonly groupBy: (args: ClientRow) => Promise<ClientRow[]>;
+} & Record<string, unknown>;
+/** What `$defineView` returns at the runtime level — the generated d.ts narrows it. */
+export type ViewClientShape = Record<string, ViewModelDelegate>;
+/** The `$defineView` client method (runtime-level shape). */
+export type DefineViewFn = (options: {
+    readonly name: string;
+    readonly definition: ViewDefinition;
+}) => ViewClientShape;
+/**
+ * A masked row: visible + revealed fields are enumerable own properties,
+ * `toJSON()` (used by `JSON.stringify`) drops revealed fields recursively,
+ * `$unsafe()` returns a plain object with everything. Class methods are
+ * prototype members, so they never show up in `Object.keys` / spread.
+ */
+export declare class ViewResult {
+    /** Dynamic property access for view/revealed/relation fields. */
+    [key: string]: unknown;
+    /** @internal Field names revealed on this row (non-enumerable). */
+    readonly _revealed: ReadonlySet<string>;
+    constructor(params: {
+        record: Readonly<Record<string, unknown>>;
+        /** Every key to expose as a property (fields + revealed + relations). */
+        expose: ReadonlySet<string>;
+        revealed: ReadonlySet<string>;
+    });
+    /** Plain object WITHOUT revealed fields (what `JSON.stringify` sees), recursively. */
+    toJSON(): Record<string, unknown>;
+    /** Plain object with ALL fields (view + revealed), recursively — the escape hatch. */
+    $unsafe(): Record<string, unknown>;
+}
+/**
+ * Build a field-masking view client over an existing client's delegates.
+ *
+ * @throws VibeError `VIBE_VALIDATION` on an invalid definition (unknown model,
+ * unknown or relation field, empty field set).
+ */
+export declare function createView(params: {
+    meta: RuntimeMeta;
+    models: Readonly<Record<string, ModelDelegate>>;
+    name: string;
+    definition: ViewDefinition;
+}): ViewClientShape;
+/**
+ * Attach `$defineView` to a built client (called by `buildClient`; transaction
+ * clients get their own attachment because `$transaction` rebuilds the client).
+ */
+export declare function attachDefineView(params: {
+    client: object;
+    meta: RuntimeMeta;
+    models: Readonly<Record<string, ModelDelegate>>;
+}): void;
+//# sourceMappingURL=views.d.ts.map

package/dist/views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../src/views.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,45 +1,50 @@
 {
   "name": "@vibeorm/runtime",
-  "version": "1.3.0",
-  "description": "Driver-agnostic query engine and client runtime for VibeORM",
-  "license": "MIT",
+  "version": "2.0.0-alpha.2",
+  "description": "Driver-agnostic query engine and client runtime for VibeORM v2",
   "keywords": [
     "orm",
-    "runtime",
-    "query-builder",
-    "bun",
     "typescript",
-    "postgresql"
+    "sql",
+    "database",
+    "bun",
+    "type-safe",
+    "query-builder",
+    "client",
+    "adapter",
+    "relations"
   ],
-  "type": "module",
-  "exports": {
-    ".": {
-      "default": "./src/index.ts",
-      "types": "./src/index.ts"
-    }
+  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/runtime#readme",
+  "bugs": {
+    "url": "https://github.com/vibeorm/vibeorm/issues"
   },
-  "files": [
-    "src"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/vibeorm/vibeorm.git",
     "directory": "packages/runtime"
   },
-  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/runtime",
-  "bugs": {
-    "url": "https://github.com/vibeorm/vibeorm/issues"
+  "license": "MIT",
+  "author": "VibeORM contributors",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "engines": {
-    "bun": ">=1.1.0"
+    "bun": ">=1.2.0"
   },
-  "peerDependencies": {
-    "zod": ">=4"
+  "dependencies": {
+    "@vibeorm/schema": "2.0.0-alpha.2",
+    "@vibeorm/sql": "2.0.0-alpha.2"
   },
-  "peerDependenciesMeta": {
-    "zod": {
-      "optional": true
-    }
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.3.0"
   },
   "publishConfig": {
     "access": "public"

package/src/adapter.ts

@@ -1,146 +0,0 @@
-/**
- * Database adapter interface for VibeORM.
- *
- * Each adapter implementation (bun:sql, pg, etc.) provides a concrete
- * implementation of this interface. The runtime is completely driver-agnostic
- * and interacts with the database exclusively through this contract.
- */
-
-// ─── Transaction Options ──────────────────────────────────────────
-
-/**
- * Options for controlling transaction behavior.
- *
- * @example
- * ```ts
- * await db.$transaction(async (tx) => {
- *   await tx.account.update({ where: { id: 1 }, data: { balance: { decrement: 100 } } });
- *   await tx.account.update({ where: { id: 2 }, data: { balance: { increment: 100 } } });
- * }, { isolationLevel: "Serializable", timeout: 5000 });
- * ```
- */
-export type TransactionOptions = {
-  /**
-   * PostgreSQL isolation level for the transaction.
-   * - "ReadCommitted" (default): Standard PostgreSQL default.
-   * - "RepeatableRead": Prevents non-repeatable reads.
-   * - "Serializable": Full serializability — conflicts throw serialization_failure.
-   */
-  isolationLevel?: "ReadCommitted" | "RepeatableRead" | "Serializable";
-  /**
-   * Maximum time in milliseconds the transaction may run before being cancelled.
-   * Implemented via `SET LOCAL statement_timeout = N` inside the transaction,
-   * so it is scoped to the transaction and does not affect other connections.
-   */
-  timeout?: number;
-};
-
-// ─── Core Adapter Interface ───────────────────────────────────────
-
-/**
- * The primary interface that every database adapter must implement.
- * Adapters own connection management, query execution, statement caching,
- * transactions, and driver-specific parameter formatting.
- */
-export type DatabaseAdapter = {
-  /**
-   * Execute a parameterized query and return rows.
-   * The adapter owns statement caching and driver-specific optimizations.
-   *
-   * For bun:sql this means synthetic tagged template caching.
-   * For pg this means named prepared statement caching.
-   */
-  execute(params: { text: string; values: unknown[] }): Promise<Record<string, unknown>[]>;
-
-  /**
-   * Execute a raw/unsafe query without prepared statement caching.
-   * Used for `$queryRawUnsafe`, `$executeRawUnsafe`, and dynamic DDL.
-   *
-   * Returns both rows and affected row count (for INSERT/UPDATE/DELETE).
-   */
-  executeUnsafe(params: {
-    text: string;
-    values?: unknown[];
-  }): Promise<QueryResult>;
-
-  /**
-   * Run a function inside a database transaction.
-   * The callback receives a transactional adapter with the same interface.
-   * If the callback throws, the transaction is automatically rolled back.
-   *
-   * @param fn - The transactional callback.
-   * @param options - Optional isolation level and timeout.
-   */
-  transaction<T>(fn: (txAdapter: DatabaseAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
-
-  /**
-   * Eagerly warm up the connection pool.
-   * Forces at least one TCP handshake + auth so subsequent queries start instantly.
-   */
-  connect(): Promise<void>;
-
-  /**
-   * Gracefully close all connections in the pool.
-   */
-  disconnect(): Promise<void>;
-
-  /**
-   * Convert a JS array to the driver's preferred format for `= ANY($N)` queries.
-   *
-   * - **bun:sql**: Returns a PG array literal string `"{val1,val2,val3}"` because
-   *   bun:sql's extended query protocol sends values as strings.
-   * - **pg**: Returns the raw JS array (pg driver handles native array serialization).
-   */
-  formatArrayParam(values: unknown[]): unknown;
-};
-
-// ─── Query Result ─────────────────────────────────────────────────
-
-/**
- * Result from an unsafe query execution.
- * Contains both the rows returned and the number of affected rows
- * (parsed from the PostgreSQL CommandComplete tag).
- */
-export type QueryResult = {
-  rows: Record<string, unknown>[];
-  affectedRows: number;
-};
-
-// ─── SQL Executor (Migration Compatibility) ───────────────────────
-
-/**
- * Minimal SQL execution interface compatible with `@vibeorm/migrate`.
- * Adapters expose this via a helper function so migrations can run
- * without knowing which adapter is in use.
- *
- * @example
- * ```ts
- * import { bunAdapter } from "@vibeorm/adapter-bun";
- * import { toSqlExecutor } from "@vibeorm/runtime";
- *
- * const adapter = bunAdapter({ url: "postgres://..." });
- * const executor = toSqlExecutor({ adapter });
- * await applyMigration({ executor, migrationName: "init", sql, checksum });
- * ```
- */
-export type SqlExecutor = (params: {
-  text: string;
-  values?: unknown[];
-}) => Promise<Record<string, unknown>[]>;
-
-/**
- * Create an SqlExecutor from a DatabaseAdapter.
- * Bridges the adapter pattern with the migrate package's SqlExecutor interface.
- */
-export function toSqlExecutor(params: {
-  adapter: DatabaseAdapter;
-}): SqlExecutor {
-  const { adapter } = params;
-  return async (queryParams) => {
-    const result = await adapter.executeUnsafe({
-      text: queryParams.text,
-      values: queryParams.values,
-    });
-    return result.rows;
-  };
-}