trellis 3.2.0 → 3.2.3

package/dist/chunk-QHA2DM3C.js

@@ -1,373 +0,0 @@
-import {
-  TenantPool
-} from "./chunk-OQNDWRDE.js";
-import {
-  readConfig
-} from "./chunk-JA7AIHRK.js";
-
-// src/client/sdk.ts
-function isRemote(opts) {
-  return "url" in opts;
-}
-var TrellisDb = class _TrellisDb {
-  opts;
-  _pool = null;
-  _ws = null;
-  /** In-flight connect — concurrent subscribe() shares one socket open. */
-  _wsPromise = null;
-  _subCallbacks = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /**
-   * Create a TrellisDb instance from `.trellis-db.json` in the given directory.
-   */
-  static fromConfig(dir = ".") {
-    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 = 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 = 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 = 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 = 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 = 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 = this._getPool();
-    const tenantId = this.opts.tenantId ?? null;
-    const kernel = pool.get(tenantId);
-    const parsed = parseSimple(eql);
-    return kernel.query(parsed);
-  }
-  // -------------------------------------------------------------------------
-  // 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 = 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 = 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) {
-    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);
-    this._ensureWs().then((ws) => {
-      ws.send(JSON.stringify({ type: "subscribe", id: subId, query: eql }));
-    });
-    return {
-      unsubscribe: () => {
-        this._subCallbacks.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.disconnect();
-  }
-  // -------------------------------------------------------------------------
-  // Private
-  // -------------------------------------------------------------------------
-  _getPool() {
-    if (!this._pool) {
-      const path = this.opts.path;
-      this._pool = new TenantPool(path);
-    }
-    return this._pool;
-  }
-  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)) {
-            this._subCallbacks.get(msg.id)(msg.result, msg.diff);
-          }
-        } 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
-};

package/dist/chunk-QLM4HSYC.js

@@ -1,45 +0,0 @@
-import {
-  TrellisDb
-} from "./chunk-7F4HM3JG.js";
-
-// src/react/provider.tsx
-import {
-  createContext,
-  useContext,
-  useMemo,
-  useEffect
-} from "react";
-var TrellisContext = createContext(null);
-function TrellisProvider({
-  url,
-  apiKey,
-  tenantId,
-  children
-}) {
-  const client = useMemo(() => {
-    const opts = { url };
-    if (apiKey) opts.apiKey = apiKey;
-    if (tenantId) opts.tenantId = tenantId;
-    return new TrellisDb(opts);
-  }, [url, apiKey, tenantId]);
-  useEffect(() => {
-    return () => {
-      client.disconnect();
-    };
-  }, [client]);
-  return /* @__PURE__ */ React.createElement(TrellisContext.Provider, { value: client }, children);
-}
-function useTrellis() {
-  const client = useContext(TrellisContext);
-  if (!client) {
-    throw new Error(
-      'useTrellis() must be used within a <TrellisProvider>. Wrap your app with <TrellisProvider url="...">.'
-    );
-  }
-  return client;
-}
-
-export {
-  TrellisProvider,
-  useTrellis
-};

package/dist/chunk-S2OT3TQJ.js

@@ -1,283 +0,0 @@
-// src/core/computation/expr-evaluator.ts
-var ExprEvaluator = class {
-  functions;
-  constructor() {
-    this.functions = /* @__PURE__ */ new Map([
-      ["$if", this.if.bind(this)],
-      ["$round", this.round.bind(this)],
-      ["$concat", this.concat.bind(this)],
-      ["$len", this.len.bind(this)],
-      ["$lower", this.lower.bind(this)],
-      ["$upper", this.upper.bind(this)],
-      ["$trim", this.trim.bind(this)],
-      ["$now", this.now.bind(this)],
-      ["$uuid", this.uuid.bind(this)],
-      ["$add", this.add.bind(this)],
-      ["$sub", this.sub.bind(this)],
-      ["$mul", this.mul.bind(this)],
-      ["$div", this.div.bind(this)],
-      ["$mod", this.mod.bind(this)],
-      ["$eq", this.eq.bind(this)],
-      ["$ne", this.ne.bind(this)],
-      ["$gt", this.gt.bind(this)],
-      ["$gte", this.gte.bind(this)],
-      ["$lt", this.lt.bind(this)],
-      ["$lte", this.lte.bind(this)],
-      ["$and", this.and.bind(this)],
-      ["$or", this.or.bind(this)],
-      ["$not", this.not.bind(this)],
-      ["$coalesce", this.coalesce.bind(this)],
-      ["$contains", this.contains.bind(this)],
-      ["$startsWith", this.startsWith.bind(this)],
-      ["$endsWith", this.endsWith.bind(this)]
-    ]);
-  }
-  /**
-   * Evaluate an expression string against a context.
-   */
-  eval(expr, context) {
-    const trimmed = expr.trim();
-    const fnMatch = trimmed.match(/^(\$\w+)\((.*)\)$/s);
-    if (fnMatch) {
-      const fnName = fnMatch[1];
-      const argsStr = fnMatch[2];
-      const fn = this.functions.get(fnName);
-      if (!fn) {
-        throw new Error(`Unknown function: ${fnName}`);
-      }
-      return this.evalFunction(fn, argsStr, context);
-    }
-    if (trimmed.startsWith("$")) {
-      const field = trimmed.slice(1);
-      return context[field];
-    }
-    if (trimmed === "true") return true;
-    if (trimmed === "false") return false;
-    if (trimmed === "null") return null;
-    const num = Number(trimmed);
-    if (!isNaN(num) && trimmed !== "") return num;
-    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-      return trimmed.slice(1, -1);
-    }
-    return trimmed;
-  }
-  evalFunction(fn, argsStr, context) {
-    const args = this.parseArgs(argsStr, context);
-    return fn(...args);
-  }
-  parseArgs(argsStr, context) {
-    const args = [];
-    let depth = 0;
-    let current = "";
-    for (let i = 0; i < argsStr.length; i++) {
-      const char = argsStr[i];
-      if (char === "(" || char === "[" || char === "{") depth++;
-      else if (char === ")" || char === "]" || char === "}") depth--;
-      else if (char === "," && depth === 0) {
-        args.push(this.eval(current.trim(), context));
-        current = "";
-        continue;
-      }
-      current += char;
-    }
-    if (current.trim()) {
-      args.push(this.eval(current.trim(), context));
-    }
-    return args;
-  }
-  // Built-in functions
-  if(cond, trueVal, falseVal) {
-    return cond ? trueVal : falseVal;
-  }
-  round(value, decimals = 0) {
-    const n = Number(value);
-    const factor = Math.pow(10, Number(decimals));
-    return Math.round(n * factor) / factor;
-  }
-  concat(...args) {
-    return args.map((a) => String(a ?? "")).join("");
-  }
-  len(value) {
-    if (typeof value === "string") return value.length;
-    if (Array.isArray(value)) return value.length;
-    return 0;
-  }
-  lower(value) {
-    return String(value ?? "").toLowerCase();
-  }
-  upper(value) {
-    return String(value ?? "").toUpperCase();
-  }
-  trim(value) {
-    return String(value ?? "").trim();
-  }
-  now() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  uuid() {
-    return crypto.randomUUID();
-  }
-  add(...args) {
-    return args.reduce((sum, a) => sum + Number(a), 0);
-  }
-  sub(a, b) {
-    return Number(a) - Number(b);
-  }
-  mul(...args) {
-    return args.reduce((prod, a) => prod * Number(a), 1);
-  }
-  div(a, b) {
-    return Number(a) / Number(b);
-  }
-  mod(a, b) {
-    return Number(a) % Number(b);
-  }
-  eq(a, b) {
-    return a === b;
-  }
-  ne(a, b) {
-    return a !== b;
-  }
-  gt(a, b) {
-    return Number(a) > Number(b);
-  }
-  gte(a, b) {
-    return Number(a) >= Number(b);
-  }
-  lt(a, b) {
-    return Number(a) < Number(b);
-  }
-  lte(a, b) {
-    return Number(a) <= Number(b);
-  }
-  and(...args) {
-    return args.every(Boolean);
-  }
-  or(...args) {
-    return args.some(Boolean);
-  }
-  not(value) {
-    return !value;
-  }
-  coalesce(...args) {
-    for (const arg of args) {
-      if (arg !== null && arg !== void 0) return arg;
-    }
-    return null;
-  }
-  contains(haystack, needle) {
-    return String(haystack ?? "").includes(String(needle ?? ""));
-  }
-  startsWith(str, prefix) {
-    return String(str ?? "").startsWith(String(prefix ?? ""));
-  }
-  endsWith(str, suffix) {
-    return String(str ?? "").endsWith(String(suffix ?? ""));
-  }
-};
-function evalExpr(expr, context) {
-  const result = new ExprEvaluator().eval(expr, context);
-  if (result === null || result === void 0) return "";
-  if (typeof result === "boolean") return result ? "true" : "false";
-  if (typeof result === "number") return result;
-  if (typeof result === "string") return result;
-  if (typeof result === "object") return JSON.stringify(result);
-  return String(result);
-}
-
-// src/core/kernel/logic-middleware.ts
-function createLogicMiddleware(config) {
-  return {
-    name: "logic-computation",
-    handleQuery(query, ctx, next) {
-      const result = next(query);
-      if (result && Array.isArray(result.bindings)) {
-        for (const binding of result.bindings) {
-          enrichBinding(binding, config, ctx);
-        }
-      }
-      return result;
-    }
-  };
-}
-function enrichBinding(binding, config, ctx) {
-  const row = binding;
-  const type = resolveEntityType(binding, config);
-  if (!type) return;
-  const schema = config.ontologies.get(type);
-  if (!schema) return;
-  for (const field of schema.fields) {
-    if (!(field.computed || field.formula || field.rollup || field.aiGenerated))
-      continue;
-    const fieldName = field.name;
-    if (fieldName in binding) continue;
-    if (field.formula) {
-      binding[fieldName] = evalExpr(field.formula, row);
-    }
-    if (field.rollup) {
-      binding[fieldName] = "";
-    }
-    if (field.aiGenerated && config.generateAiField) {
-      const prompt = field.aiGenerated.prompt.replace(
-        /\{\{(\w+)\}\}/g,
-        (_, key) => String(row[key] ?? "")
-      );
-      config.generateAiField(prompt, row).then((value) => {
-        binding[fieldName] = value;
-      }).catch(() => {
-        binding[fieldName] = "";
-      });
-    }
-  }
-}
-function resolveEntityType(binding, config) {
-  const explicit = binding.type;
-  if (typeof explicit === "string" && explicit.length > 0) return explicit;
-  const entityId = findEntityId(binding);
-  if (entityId && config.getEntityType) {
-    return config.getEntityType(entityId);
-  }
-  return void 0;
-}
-function findEntityId(binding) {
-  for (const value of Object.values(binding)) {
-    if (typeof value === "string" && value.includes(":")) return value;
-  }
-  return void 0;
-}
-
-// src/core/kernel/boot-middleware.ts
-function buildOntologyIndex(schemas) {
-  const map = /* @__PURE__ */ new Map();
-  for (const schema of schemas) {
-    map.set(schema["@id"], schema);
-    const short = schema["@id"].includes(":") ? schema["@id"].split(":").pop() : schema["@id"];
-    if (short) {
-      map.set(short, schema);
-      map.set(short.toLowerCase(), schema);
-    }
-    if (schema.label) {
-      map.set(schema.label, schema);
-      map.set(schema.label.toLowerCase(), schema);
-    }
-  }
-  return map;
-}
-function attachStandardMiddleware(kernel) {
-  kernel.removeMiddleware("logic-computation");
-  const ontologies = buildOntologyIndex(kernel.listOntologies());
-  kernel.addMiddleware(
-    createLogicMiddleware({
-      ontologies,
-      getEntityType: (entityId) => kernel.getEntity(entityId)?.type
-    })
-  );
-}
-
-export {
-  ExprEvaluator,
-  evalExpr,
-  createLogicMiddleware,
-  buildOntologyIndex,
-  attachStandardMiddleware
-};