trellis 3.1.35 → 3.2.2

package/dist/chunk-JUEMDWLU.js

@@ -0,0 +1,233 @@
+// src/schema/entity-projection.ts
+function entityRecordToPlain(entity) {
+  const obj = { id: entity.id, type: entity.type };
+  for (const f of entity.facts) {
+    if (f.a !== "type") obj[f.a] = f.v;
+  }
+  return obj;
+}
+function bindingEntityId(row) {
+  const id = row.id ?? row.e ?? row["?e"];
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+function isSparseBinding(row) {
+  const id = bindingEntityId(row);
+  if (!id) return false;
+  return typeof row.type !== "string";
+}
+function bindingToEntity(row) {
+  const id = bindingEntityId(row);
+  if (id && typeof row.type === "string") {
+    return { ...row, id, type: row.type };
+  }
+  if (id) return { id, type: String(row.type ?? ""), ...row };
+  return row;
+}
+function hydrateBindings(kernel, bindings) {
+  return bindings.map((row) => {
+    if (!isSparseBinding(row)) return bindingToEntity(row);
+    const id = bindingEntityId(row);
+    const entity = kernel.getEntity(id);
+    return entity ? entityRecordToPlain(entity) : bindingToEntity(row);
+  });
+}
+
+// src/schema/eql.ts
+function escapeValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+var WHERE_OP_TO_EQL = {
+  eq: "=",
+  ne: "!=",
+  lt: "<",
+  lte: "<=",
+  gt: ">",
+  gte: ">=",
+  contains: "contains",
+  startsWith: "startsWith",
+  endsWith: "endsWith"
+};
+function isWhereFilter(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.keys(WHERE_OP_TO_EQL).some(
+    (op) => value[op] !== void 0
+  );
+}
+function formatEqlLiteral(value) {
+  if (typeof value === "string") return `"${escapeValue(value)}"`;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (value === null || value === void 0) {
+    throw new Error("Cannot format null/undefined as an EQL literal");
+  }
+  return `"${escapeValue(String(value))}"`;
+}
+function whereCondition(attr, value) {
+  if (isWhereFilter(value)) {
+    const ops = Object.keys(WHERE_OP_TO_EQL).filter(
+      (op2) => value[op2] !== void 0
+    );
+    if (ops.length === 0) {
+      throw new Error(`Empty where filter for attribute "${attr}"`);
+    }
+    if (ops.length > 1) {
+      throw new Error(
+        `Where filter for "${attr}" must specify one operator, got: ${ops.join(", ")}`
+      );
+    }
+    const op = ops[0];
+    return `${attr} ${WHERE_OP_TO_EQL[op]} ${formatEqlLiteral(value[op])}`;
+  }
+  return `${attr} = ${formatEqlLiteral(value)}`;
+}
+function entitiesQuery(type, where) {
+  const conds = [`type = "${escapeValue(type)}"`];
+  for (const [k, v] of Object.entries(where ?? {})) {
+    if (v === void 0 || v === null) continue;
+    conds.push(whereCondition(k, v));
+  }
+  return `find ?e where ${conds.join(" and ")}`;
+}
+function entityQuery(type, entityId) {
+  const t = formatEqlLiteral(type);
+  const id = formatEqlLiteral(entityId);
+  return `SELECT ?e
+WHERE {
+  [?e "type" ${t}]
+}
+FILTER ?e = ${id}`;
+}
+
+// src/schema/resolve.ts
+function isNestedResolveSpec(v) {
+  return typeof v === "object" && v !== null;
+}
+function relationTargetName(r) {
+  return typeof r.target === "string" ? r.target : r.target().type;
+}
+function relationTargetSchema(r, schemaLookup) {
+  if (typeof r.target !== "string") return r.target();
+  return schemaLookup?.(r.target) ?? null;
+}
+function inverseForeignKey(parent, relationName, child) {
+  for (const [key, r] of Object.entries(child.relations)) {
+    if (relationTargetName(r) === parent.type) return key;
+  }
+  return null;
+}
+async function loadByIds(client, ids, cache) {
+  const missing = ids.filter((id) => !cache.has(id));
+  if (missing.length === 0) return;
+  await Promise.all(
+    missing.map(async (id) => {
+      cache.set(id, await client.read(id));
+    })
+  );
+}
+async function resolveReverseMany(client, parent, relationName, parents, cache, schemaLookup) {
+  const rel = parent.relations[relationName];
+  if (!rel || rel.cardinality !== "many") return;
+  const childSchema = relationTargetSchema(rel, schemaLookup);
+  if (!childSchema) return;
+  const foreignKey = inverseForeignKey(parent, relationName, childSchema);
+  if (!foreignKey) return;
+  const parentIds = new Set(parents.map((p) => p.id));
+  const qr = await client.query(entitiesQuery(childSchema.type));
+  const childIds = qr.bindings.map((b) => bindingEntityId(b)).filter((id) => Boolean(id));
+  await loadByIds(client, childIds, cache);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const id of childIds) {
+    const child = cache.get(id);
+    if (!child) continue;
+    const fk = child[foreignKey];
+    if (typeof fk !== "string" || !parentIds.has(fk)) continue;
+    if (!grouped.has(fk)) grouped.set(fk, []);
+    grouped.get(fk).push(child);
+  }
+  for (const row of parents) {
+    row[relationName] = grouped.get(row.id) ?? [];
+  }
+}
+async function resolveForwardOne(client, parents, relationName, cache) {
+  const ids = parents.map((p) => p[relationName]).filter((v) => typeof v === "string" && v.length > 0);
+  await loadByIds(client, ids, cache);
+  for (const row of parents) {
+    const ref = row[relationName];
+    if (typeof ref !== "string") continue;
+    const loaded = cache.get(ref);
+    if (loaded) row[relationName] = loaded;
+  }
+}
+async function resolveRelations(client, schema, entities, spec, opts) {
+  if (entities.length === 0 || Object.keys(spec).length === 0) return entities;
+  const cache = /* @__PURE__ */ new Map();
+  const rows = opts?.copy === false ? entities : entities.map((e) => ({ ...e }));
+  for (const [name, enabled] of Object.entries(spec)) {
+    if (!enabled) continue;
+    const rel = schema.relations[name];
+    if (!rel) continue;
+    if (rel.cardinality === "many") {
+      await resolveReverseMany(
+        client,
+        schema,
+        name,
+        rows,
+        cache,
+        opts?.schemaLookup
+      );
+      if (isNestedResolveSpec(enabled)) {
+        const childSchema = relationTargetSchema(rel, opts?.schemaLookup);
+        if (childSchema) {
+          for (const row of rows) {
+            const kids = row[name];
+            if (kids?.length) {
+              await resolveRelations(client, childSchema, kids, enabled, {
+                copy: false,
+                schemaLookup: opts?.schemaLookup
+              });
+            }
+          }
+        }
+      }
+    } else if (isNestedResolveSpec(enabled)) {
+      await resolveForwardOne(client, rows, name, cache);
+      const childSchema = relationTargetSchema(rel, opts?.schemaLookup);
+      if (childSchema) {
+        const nested = [];
+        for (const row of rows) {
+          const loaded = row[name];
+          if (loaded && typeof loaded === "object" && "id" in loaded) {
+            nested.push(loaded);
+          }
+        }
+        if (nested.length) {
+          await resolveRelations(client, childSchema, nested, enabled, {
+            copy: false,
+            schemaLookup: opts?.schemaLookup
+          });
+        }
+      }
+    } else {
+      await resolveForwardOne(client, rows, name, cache);
+    }
+  }
+  return rows;
+}
+
+export {
+  entityRecordToPlain,
+  bindingEntityId,
+  isSparseBinding,
+  bindingToEntity,
+  hydrateBindings,
+  escapeValue,
+  isWhereFilter,
+  formatEqlLiteral,
+  whereCondition,
+  entitiesQuery,
+  entityQuery,
+  inverseForeignKey,
+  resolveRelations
+};

package/dist/chunk-KFQGP6VL.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-KIJITUZB.js

@@ -0,0 +1,419 @@
+// src/client/sdk.ts
+function isRemote(opts) {
+  return "url" in opts;
+}
+var TrellisDb = class _TrellisDb {
+  opts;
+  _pool = null;
+  _poolPromise = null;
+  _ws = null;
+  /** In-flight connect — concurrent subscribe() shares one socket open. */
+  _wsPromise = null;
+  _subCallbacks = /* @__PURE__ */ new Map();
+  _subOpts = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Create a TrellisDb instance from `.trellis-db.json` in the given directory.
+   */
+  static async fromConfig(dir = ".") {
+    const { readConfig } = await import("./config-PFTP67TR.js");
+    const config = readConfig(dir);
+    if (!config)
+      throw new Error(
+        "No .trellis-db.json found. Run `trellis db init` first."
+      );
+    if (config.mode === "remote" && config.url) {
+      return new _TrellisDb({ url: config.url, apiKey: config.apiKey });
+    }
+    if (config.dbPath) {
+      return new _TrellisDb({ path: config.dbPath });
+    }
+    throw new Error("Invalid .trellis-db.json: missing url or dbPath.");
+  }
+  // -------------------------------------------------------------------------
+  // CRUD
+  // -------------------------------------------------------------------------
+  /**
+   * Create a new entity.
+   * Returns the generated entity ID.
+   */
+  async create(type, attributes = {}, links) {
+    if (isRemote(this.opts)) {
+      const res = await this._fetch("POST", "/entities", {
+        type,
+        attributes,
+        links
+      });
+      return res.id;
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entityId = `${type.toLowerCase()}:${crypto.randomUUID()}`;
+    await kernel.createEntity(entityId, type, attributes, links);
+    return entityId;
+  }
+  /**
+   * Read an entity by ID.
+   * Returns null if not found.
+   */
+  async read(id) {
+    if (isRemote(this.opts)) {
+      try {
+        return await this._fetch(
+          "GET",
+          `/entities/${encodeURIComponent(id)}`
+        );
+      } catch (err) {
+        if (err?.status === 404) return null;
+        throw err;
+      }
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entity = kernel.getEntity(id);
+    if (!entity) return null;
+    return entityToPlain(entity);
+  }
+  /**
+   * Update an entity's attributes (partial update).
+   */
+  async update(id, attributes) {
+    if (isRemote(this.opts)) {
+      await this._fetch(
+        "PUT",
+        `/entities/${encodeURIComponent(id)}`,
+        attributes
+      );
+      return;
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    await kernel.updateEntity(id, attributes);
+  }
+  /**
+   * Delete an entity by ID.
+   */
+  async delete(id) {
+    if (isRemote(this.opts)) {
+      await this._fetch("DELETE", `/entities/${encodeURIComponent(id)}`);
+      return;
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    await kernel.deleteEntity(id);
+  }
+  /**
+   * List entities of a given type.
+   */
+  async list(type, opts = {}) {
+    if (isRemote(this.opts)) {
+      const params = new URLSearchParams();
+      if (type) params.set("type", type);
+      if (opts.limit) params.set("limit", String(opts.limit));
+      if (opts.offset) params.set("offset", String(opts.offset));
+      const qs = params.toString() ? `?${params}` : "";
+      return await this._fetch("GET", `/entities${qs}`);
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entities = kernel.listEntities(type, opts.filters);
+    const limit = opts.limit ?? 100;
+    const offset = opts.offset ?? 0;
+    const page = entities.slice(offset, offset + limit);
+    return {
+      data: page.map(entityToPlain),
+      total: entities.length,
+      limit,
+      offset
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Query
+  // -------------------------------------------------------------------------
+  /**
+   * Run an EQL-S query string.
+   */
+  async query(eql) {
+    if (isRemote(this.opts)) {
+      return await this._fetch("POST", "/query", {
+        query: eql
+      });
+    }
+    const { parseSimple } = await import("./query-XYLTJYSA.js");
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const parsed = parseSimple(eql);
+    return kernel.query(parsed);
+  }
+  // -------------------------------------------------------------------------
+  // Schema registration
+  // -------------------------------------------------------------------------
+  /**
+   * Register a user/system-tier ontology schema with the kernel.
+   *
+   * Accepts a {@link SchemaDefinition} or anything carrying one (e.g. a
+   * `defineType` handle: `client.registerType(NavItem)`). Local mode calls
+   * `kernel.createOntology` directly; remote mode POSTs to `/ontologies`.
+   */
+  async registerType(schema) {
+    const def = "@id" in schema ? schema : schema.definition;
+    if (isRemote(this.opts)) {
+      try {
+        await this._fetch("POST", "/ontologies", def);
+      } catch (err) {
+        if (err instanceof FetchError && err.status === 409) return;
+        throw err;
+      }
+      return;
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const exists = kernel.listOntologies().some((ont) => ont["@id"] === def["@id"]);
+    if (exists) return;
+    try {
+      kernel.createOntology(def);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("already exists")) return;
+      throw err;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // File upload
+  // -------------------------------------------------------------------------
+  /**
+   * Upload a file to the blob store.
+   * Returns a content-addressed hash.
+   */
+  async upload(data, contentType = "application/octet-stream") {
+    const raw = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const cleanBuf = raw.buffer.slice(
+      raw.byteOffset,
+      raw.byteOffset + raw.byteLength
+    );
+    const buffer = new Uint8Array(cleanBuf);
+    if (isRemote(this.opts)) {
+      const res = await fetch(`${this.opts.url}/upload`, {
+        method: "POST",
+        headers: {
+          "Content-Type": contentType,
+          ...this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        },
+        body: cleanBuf
+      });
+      if (!res.ok) throw new FetchError(res.status, await res.text());
+      return await res.json();
+    }
+    const hashBuf = await crypto.subtle.digest("SHA-256", buffer);
+    const hash = `blob:${Array.from(new Uint8Array(hashBuf)).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const backend = kernel.getBackend();
+    if (!backend.hasBlob(hash)) backend.putBlob(hash, buffer);
+    return { hash, size: buffer.length, contentType };
+  }
+  /**
+   * Download a file by its blob hash.
+   */
+  async getFile(hash) {
+    if (isRemote(this.opts)) {
+      const res = await fetch(
+        `${this.opts.url}/files/${encodeURIComponent(hash)}`,
+        {
+          headers: this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        }
+      );
+      if (res.status === 404) return null;
+      if (!res.ok) throw new FetchError(res.status, await res.text());
+      return new Uint8Array(await res.arrayBuffer());
+    }
+    const pool = await this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const backend = kernel.getBackend();
+    return backend.getBlob(hash) ?? null;
+  }
+  // -------------------------------------------------------------------------
+  // Auth helpers
+  // -------------------------------------------------------------------------
+  async register(email, password, name) {
+    if (!isRemote(this.opts))
+      throw new Error("register() requires remote mode");
+    return await this._fetch("POST", "/auth/register", {
+      email,
+      password,
+      name
+    });
+  }
+  async login(email, password) {
+    if (!isRemote(this.opts)) throw new Error("login() requires remote mode");
+    return await this._fetch("POST", "/auth/login", {
+      email,
+      password
+    });
+  }
+  /**
+   * Set the active API key / JWT token for subsequent requests.
+   */
+  setToken(token) {
+    if (!isRemote(this.opts)) return;
+    this.opts.apiKey = token;
+  }
+  // -------------------------------------------------------------------------
+  // Realtime
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribe to a live EQL-S query.
+   * Callback is fired immediately with the initial result, then on every update.
+   *
+   * Requires remote mode (WebSocket to server).
+   */
+  subscribe(eql, callback, opts) {
+    if (!isRemote(this.opts)) {
+      throw new Error(
+        "subscribe() requires remote mode (connect to a running server)"
+      );
+    }
+    const subId = `sub_${crypto.randomUUID()}`;
+    this._subCallbacks.set(subId, callback);
+    if (opts) this._subOpts.set(subId, opts);
+    this._ensureWs().then((ws) => {
+      ws.send(
+        JSON.stringify({
+          type: "subscribe",
+          id: subId,
+          query: eql,
+          ...opts?.entityType ? { entityType: opts.entityType } : {},
+          ...opts?.resolve ? { resolve: opts.resolve } : {}
+        })
+      );
+    });
+    return {
+      unsubscribe: () => {
+        this._subCallbacks.delete(subId);
+        this._subOpts.delete(subId);
+        this._ws?.send(JSON.stringify({ type: "unsubscribe", id: subId }));
+      }
+    };
+  }
+  /**
+   * Close the WebSocket connection.
+   */
+  disconnect() {
+    const ws = this._ws;
+    this._ws = null;
+    this._wsPromise = null;
+    ws?.close();
+  }
+  /**
+   * Close local kernel pool connections.
+   */
+  close() {
+    this._pool?.closeAll();
+    this._pool = null;
+    this._poolPromise = null;
+    this.disconnect();
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  async _getPool() {
+    if (this._pool) return this._pool;
+    if (!this._poolPromise) {
+      this._poolPromise = import("./tenancy-NBLLGCNJ.js").then(({ TenantPool }) => {
+        const path = this.opts.path;
+        this._pool = new TenantPool(path);
+        return this._pool;
+      });
+    }
+    return this._poolPromise;
+  }
+  async _fetch(method, path, body) {
+    const opts = this.opts;
+    const url = `${opts.url}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const data = await res.json();
+    if (!res.ok)
+      throw new FetchError(
+        res.status,
+        data?.message ?? res.statusText,
+        data
+      );
+    return data;
+  }
+  _ensureWs() {
+    if (this._ws?.readyState === WebSocket.OPEN) {
+      return Promise.resolve(this._ws);
+    }
+    if (this._wsPromise) {
+      return this._wsPromise;
+    }
+    const opts = this.opts;
+    const wsUrl = opts.url.replace(/^https?/, opts.url.startsWith("https") ? "wss" : "ws") + "/realtime";
+    this._wsPromise = new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        this._ws = ws;
+        resolve(ws);
+      };
+      ws.onerror = (e) => {
+        reject(e instanceof Error ? e : new Error("WebSocket error"));
+      };
+      ws.onmessage = (e) => {
+        try {
+          const msg = JSON.parse(e.data);
+          if (msg.type === "data" && this._subCallbacks.has(msg.id)) {
+            const meta = msg.resolved === true ? { resolved: true } : void 0;
+            this._subCallbacks.get(msg.id)(msg.result, msg.diff, meta);
+          }
+        } catch {
+        }
+      };
+      ws.onclose = () => {
+        if (this._ws === ws) {
+          this._ws = null;
+        }
+      };
+    }).finally(() => {
+      this._wsPromise = null;
+    });
+    return this._wsPromise;
+  }
+};
+function entityToPlain(entity) {
+  const obj = { id: entity.id, type: entity.type };
+  for (const f of entity.facts) {
+    if (f.a !== "type") obj[f.a] = f.v;
+  }
+  return obj;
+}
+var FetchError = class extends Error {
+  constructor(status, message, body) {
+    super(`HTTP ${status}: ${message}`);
+    this.status = status;
+    this.body = body;
+    this.name = "FetchError";
+  }
+};
+
+export {
+  TrellisDb,
+  FetchError
+};