marcidb-client 0.3.1 → 0.6.1

package/README.md

@@ -1,85 +1,85 @@
-# marci-db
-
-TypeScript client for [MarciDB](https://github.com/den59k/marci-db.git) — a NoSQL database with a schema-first approach.
-
-## Installation
-
-```bash
-npm install marcidb-client
-# or
-bun add marcidb-client
-```
-
-## Setup
-
-1. Create a `schema.marci` file in your project root:
-
-```
-model User {
-    name    String
-    posts   Post[]  @bind(Post.author)
-}
-
-model Post {
-    title   String
-    author  User?
-}
-```
-
-2. Generate the client:
-
-```bash
-marcidb generate
-# or with custom paths
-marcidb generate schema.marci node_modules/.marcidb/client
-```
-
-3. Start your MarciDB server and connect:
-
-```typescript
-import { marcidb } from "marcidb-client";
-
-const db = marcidb("http://localhost:3000");
-```
-
-## Usage
-
-```typescript
-import { marcidb } from "marcidb-client";
-
-const db = marcidb("http://localhost:3000");
-
-// Find
-const users = await db.user.findMany({
-  id: true,
-  name: true,
-});
-
-// Insert
-const id = await db.user.insert({
-  name: "Alice",
-});
-
-// Update
-await db.user.update({ id: 1 }, {
-  name: "Bob",
-});
-
-// Delete
-await db.user.delete({ id: 1 });
-```
-
-## Requirements
-
-- Node.js 18+ or Bun
-- MarciDB server running
-
-## Re-generating types
-
-After every change to `schema.marci`, re-run:
-
-```bash
-marcidb generate
-```
-
+# marci-db
+
+TypeScript client for [MarciDB](https://github.com/den59k/marci-db.git) — a NoSQL database with a schema-first approach.
+
+## Installation
+
+```bash
+npm install marcidb-client
+# or
+bun add marcidb-client
+```
+
+## Setup
+
+1. Create a `schema.marci` file in your project root:
+
+```
+model User {
+    name    String
+    posts   Post[]  @bind(Post.author)
+}
+
+model Post {
+    title   String
+    author  User?
+}
+```
+
+2. Generate the client:
+
+```bash
+marcidb generate
+# or with custom paths
+marcidb generate schema.marci node_modules/.marcidb/client
+```
+
+3. Start your MarciDB server and connect:
+
+```typescript
+import { marcidb } from "marcidb-client";
+
+const db = marcidb("http://localhost:3000");
+```
+
+## Usage
+
+```typescript
+import { marcidb } from "marcidb-client";
+
+const db = marcidb("http://localhost:3000");
+
+// Find
+const users = await db.user.findMany({
+  id: true,
+  name: true,
+});
+
+// Insert
+const id = await db.user.insert({
+  name: "Alice",
+});
+
+// Update
+await db.user.update({ id: 1 }, {
+  name: "Bob",
+});
+
+// Delete
+await db.user.delete({ id: 1 });
+```
+
+## Requirements
+
+- Node.js 18+ or Bun
+- MarciDB server running
+
+## Re-generating types
+
+After every change to `schema.marci`, re-run:
+
+```bash
+marcidb generate
+```
+
 If types don't update in VSCode, run **TypeScript: Restart TS Server** (`Ctrl+Shift+P`).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "marcidb-client",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.6.1",
   "license": "MIT",
   "author": {
     "name": "den59k"

package/runtime/index.d.ts

@@ -1,3 +1,18 @@
-declare function request(method: string, url: string, body?: any);
-declare function encodeId(id: any);
-export { request, encodeId };
+declare function request(method: string, url: string, body?: any): Promise<any>;
+type FieldDesc = {
+	n: string;
+	k: "key" | "body" | "one" | "many";
+	t?: string | null;
+	m?: string;
+};
+/**
+* Builds the binary decoder registry for a set of models. `MODELS` maps each model name to its ordered
+* field descriptors (emitted by codegen). Returns `getDecoder` (shape → cached decoder, or `null` when the
+* shape isn't binary-decodable → caller falls back to JSON) and `decodeBuffer` (run a decoder over a buffer).
+*/
+declare function createDecoderRegistry(MODELS: Record<string, FieldDesc[]>): {
+	getDecoder(model: string, select: Record<string, any> | undefined): ((reader: any) => any) | null;
+	decodeBuffer(decoder: (reader: any) => any, bytes: Uint8Array, many: boolean): any;
+};
+declare function encodeId(id: any): string;
+export { request, encodeId, createDecoderRegistry };

package/runtime/index.js

@@ -11,6 +11,180 @@ async function request(method, url, body) {
   }
   return res.json();
 }
+var BINARY_VERSION = 1;
+var AGG_KEYS = ["$count", "$sum", "$avg", "$min", "$max"];
+
+class BinReader {
+  o = 0;
+  dv;
+  bytes;
+  static decoder = new TextDecoder;
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  u8() {
+    return this.dv.getUint8(this.o++);
+  }
+  u32() {
+    const v = this.dv.getUint32(this.o, true);
+    this.o += 4;
+    return v;
+  }
+  i64() {
+    const v = Number(this.dv.getBigInt64(this.o, true));
+    this.o += 8;
+    return v;
+  }
+  u64() {
+    const v = Number(this.dv.getBigUint64(this.o, true));
+    this.o += 8;
+    return v;
+  }
+  f64() {
+    const v = this.dv.getFloat64(this.o, true);
+    this.o += 8;
+    return v;
+  }
+  str() {
+    const len = this.u32();
+    const s = BinReader.decoder.decode(this.bytes.subarray(this.o, this.o + len));
+    this.o += len;
+    return s;
+  }
+}
+function readScalar(r, t) {
+  switch (t) {
+    case "str":
+      return r.str();
+    case "i64":
+      return r.i64();
+    case "u64":
+      return r.u64();
+    case "f64":
+      return r.f64();
+    case "bool":
+      return r.u8() !== 0;
+    case "u8":
+      return r.u8();
+    default:
+      throw new Error(`marcidb: unknown binary type code '${t}'`);
+  }
+}
+function createDecoderRegistry(MODELS) {
+  const cache = new Map;
+  const isSel = (v) => v !== undefined && v !== false;
+  function allSelect(model) {
+    const out = {};
+    for (const f of MODELS[model] ?? []) {
+      if (f.k === "key" || f.k === "body")
+        out[f.n] = true;
+    }
+    return out;
+  }
+  function projectionKey(model, select) {
+    const fields = MODELS[model];
+    if (!fields)
+      return "?";
+    const known = new Set(fields.map((f) => f.n));
+    let key = model + "(";
+    for (const f of fields) {
+      const sel = select[f.n];
+      if (!isSel(sel))
+        continue;
+      if (f.k === "one" || f.k === "many") {
+        const sub = sel === true ? allSelect(f.m) : sel;
+        key += f.n + "{" + projectionKey(f.m, sub) + "}";
+      } else {
+        key += f.n + ",";
+      }
+    }
+    const unknown = Object.keys(select).filter((k) => k[0] !== "$" && !known.has(k) && isSel(select[k])).sort();
+    if (unknown.length)
+      key += "!" + unknown.join("!");
+    return key + ")";
+  }
+  function build(model, select) {
+    const fields = MODELS[model];
+    if (!fields)
+      return null;
+    const known = new Set(fields.map((f) => f.n));
+    for (const k in select) {
+      if (k[0] === "$")
+        continue;
+      if (!known.has(k) && isSel(select[k]))
+        return null;
+    }
+    const steps = [];
+    const rels = [];
+    for (const f of fields) {
+      const sel = select[f.n];
+      if (!isSel(sel))
+        continue;
+      if (f.k === "one" || f.k === "many") {
+        if (f.k === "many" && sel && typeof sel === "object" && AGG_KEYS.some((k) => (k in sel)))
+          return null;
+        const sub = sel === true ? allSelect(f.m) : sel;
+        const fn = build(f.m, sub);
+        if (!fn)
+          return null;
+        rels.push({ name: f.n, many: f.k === "many", fn });
+      } else {
+        if (f.t == null)
+          return null;
+        steps.push({ name: f.n, key: f.k === "key", t: f.t });
+      }
+    }
+    return (r) => {
+      const obj = {};
+      for (let i = 0;i < steps.length; i++) {
+        const s = steps[i];
+        if (s.key) {
+          obj[s.name] = readScalar(r, s.t);
+        } else {
+          obj[s.name] = r.u8() === 0 ? null : readScalar(r, s.t);
+        }
+      }
+      for (let i = 0;i < rels.length; i++) {
+        const rel = rels[i];
+        if (rel.many) {
+          const n = r.u32();
+          const arr = new Array(n);
+          for (let j = 0;j < n; j++)
+            arr[j] = rel.fn(r);
+          obj[rel.name] = arr;
+        } else {
+          obj[rel.name] = r.u8() === 0 ? null : rel.fn(r);
+        }
+      }
+      return obj;
+    };
+  }
+  function getDecoder(model, select) {
+    const sel = select ?? {};
+    const key = projectionKey(model, sel);
+    if (cache.has(key))
+      return cache.get(key);
+    const fn = build(model, sel);
+    cache.set(key, fn);
+    return fn;
+  }
+  function decodeBuffer(decoder, bytes, many) {
+    const r = new BinReader(bytes);
+    const version = r.u8();
+    if (version !== BINARY_VERSION)
+      throw new Error(`marcidb: unsupported binary result version ${version}`);
+    const count = r.u32();
+    if (many) {
+      const out = new Array(count);
+      for (let i = 0;i < count; i++)
+        out[i] = decoder(r);
+      return out;
+    }
+    return count === 0 ? null : decoder(r);
+  }
+  return { getDecoder, decodeBuffer };
+}
 function encodeId(id) {
   if (typeof id === "object" && id !== null) {
     const parts = [];
@@ -31,5 +205,6 @@ function encodeId(id) {
 }
 export {
   request,
-  encodeId
+  encodeId,
+  createDecoderRegistry
 };

package/client/index.d.ts

@@ -1,2 +0,0 @@
-// Types for the generated client (see client/index.js for why this is a relative path, not a bare specifier).
-export * from '../../.marcidb/client'

package/client/index.js

@@ -1,5 +0,0 @@
-// Re-export the generated client (default location: node_modules/.marcidb/client). A relative path is
-// used deliberately: the bare specifier `.marcidb/client` is an INVALID ESM specifier on Node
-// (ERR_INVALID_MODULE_SPECIFIER — it starts with "." but not "./"). A `../` relative path is valid on
-// Node and Bun, and resolves the runtime-generated dir without needing it installed as a package.
-export * from '../../.marcidb/client/index.js'