trellis 3.2.0 → 3.2.3

package/dist/chunk-G3XIHPSQ.js

@@ -1,361 +0,0 @@
-import {
-  __esm
-} from "./chunk-2ESYSVXG.js";
-
-// src/core/store/eav-store.ts
-function* flatten(obj, base = "") {
-  if (Array.isArray(obj)) {
-    for (const v of obj) {
-      yield* flatten(v, base);
-    }
-  } else if (obj && typeof obj === "object") {
-    for (const [k, v] of Object.entries(obj)) {
-      yield* flatten(v, base ? `${base}.${k}` : k);
-    }
-  } else {
-    yield [base, obj];
-  }
-}
-function jsonEntityFacts(entityId, root, type) {
-  const facts = [{ e: entityId, a: "type", v: type }];
-  for (const [a, v] of flatten(root)) {
-    if (v === void 0 || v === null) continue;
-    if (Array.isArray(v)) {
-      for (const el of v) {
-        facts.push({ e: entityId, a, v: el });
-      }
-    } else if (typeof v === "object") {
-    } else {
-      facts.push({ e: entityId, a, v });
-    }
-  }
-  return facts;
-}
-var EAVStore;
-var init_eav_store = __esm({
-  "src/core/store/eav-store.ts"() {
-    "use strict";
-    EAVStore = class {
-      facts = [];
-      links = [];
-      catalog = /* @__PURE__ */ new Map();
-      // Indexes for fast lookups
-      eavIndex = /* @__PURE__ */ new Map();
-      aevIndex = /* @__PURE__ */ new Map();
-      aveIndex = /* @__PURE__ */ new Map();
-      // Link indexes for graph queries
-      linkIndex = /* @__PURE__ */ new Map();
-      // e1 -> a -> e2s
-      linkReverseIndex = /* @__PURE__ */ new Map();
-      // e2 -> a -> e1s
-      linkAttrIndex = /* @__PURE__ */ new Map();
-      // a -> [(e1, e2)]
-      // Distinct value tracking
-      distinct = /* @__PURE__ */ new Map();
-      // attr -> set of valueKey
-      addFacts(facts) {
-        for (let i = 0; i < facts.length; i++) {
-          const fact = facts[i];
-          if (fact) {
-            if (this.hasFact(fact.e, fact.a, fact.v)) {
-              continue;
-            }
-            this.facts.push(fact);
-            this.updateIndexes(fact, this.facts.length - 1);
-            this.updateCatalog(fact);
-          }
-        }
-      }
-      /**
-       * Check if a fact already exists in the store.
-       */
-      hasFact(entity, attribute, value) {
-        const valueKey = this.valueKey(value);
-        const indices = this.aveIndex.get(attribute)?.get(valueKey);
-        if (!indices) return false;
-        for (const idx of indices) {
-          const fact = this.facts[idx];
-          if (fact && fact.e === entity && fact.a === attribute) {
-            return true;
-          }
-        }
-        return false;
-      }
-      addLinks(links) {
-        for (const link of links) {
-          this.links.push(link);
-          this.updateLinkIndexes(link);
-        }
-      }
-      deleteFacts(factsToDelete) {
-        for (const fact of factsToDelete) {
-          const valueKey = this.valueKey(fact.v);
-          const indices = this.aveIndex.get(fact.a)?.get(valueKey);
-          if (!indices) continue;
-          let foundIdx = -1;
-          for (const idx of indices) {
-            const storedFact = this.facts[idx];
-            if (storedFact && storedFact.e === fact.e && storedFact.a === fact.a) {
-              foundIdx = idx;
-              break;
-            }
-          }
-          if (foundIdx !== -1) {
-            this.facts[foundIdx] = void 0;
-            this.eavIndex.get(fact.e)?.get(fact.a)?.delete(foundIdx);
-            this.aevIndex.get(fact.a)?.get(fact.e)?.delete(foundIdx);
-            this.aveIndex.get(fact.a)?.get(valueKey)?.delete(foundIdx);
-            const entry = this.catalog.get(fact.a);
-            if (entry) {
-            }
-          }
-        }
-      }
-      deleteLinks(linksToDelete) {
-        for (const link of linksToDelete) {
-          const initialLen = this.links.length;
-          this.links = this.links.filter(
-            (l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2)
-          );
-          if (this.links.length < initialLen) {
-            this.linkIndex.get(link.e1)?.get(link.a)?.delete(link.e2);
-            this.linkReverseIndex.get(link.e2)?.get(link.a)?.delete(link.e1);
-            const attrPairs = this.linkAttrIndex.get(link.a);
-            if (attrPairs) {
-              for (const pair of attrPairs) {
-                if (pair[0] === link.e1 && pair[1] === link.e2) {
-                  attrPairs.delete(pair);
-                  break;
-                }
-              }
-            }
-          }
-        }
-      }
-      updateIndexes(fact, index) {
-        if (!this.eavIndex.has(fact.e)) {
-          this.eavIndex.set(fact.e, /* @__PURE__ */ new Map());
-        }
-        if (!this.eavIndex.get(fact.e).has(fact.a)) {
-          this.eavIndex.get(fact.e).set(fact.a, /* @__PURE__ */ new Set());
-        }
-        this.eavIndex.get(fact.e).get(fact.a).add(index);
-        if (!this.aevIndex.has(fact.a)) {
-          this.aevIndex.set(fact.a, /* @__PURE__ */ new Map());
-        }
-        if (!this.aevIndex.get(fact.a).has(fact.e)) {
-          this.aevIndex.get(fact.a).set(fact.e, /* @__PURE__ */ new Set());
-        }
-        this.aevIndex.get(fact.a).get(fact.e).add(index);
-        if (!this.aveIndex.has(fact.a)) {
-          this.aveIndex.set(fact.a, /* @__PURE__ */ new Map());
-        }
-        const valueKey = this.valueKey(fact.v);
-        if (!this.aveIndex.get(fact.a).has(valueKey)) {
-          this.aveIndex.get(fact.a).set(valueKey, /* @__PURE__ */ new Set());
-        }
-        this.aveIndex.get(fact.a).get(valueKey).add(index);
-      }
-      updateLinkIndexes(link) {
-        if (!this.linkIndex.has(link.e1)) {
-          this.linkIndex.set(link.e1, /* @__PURE__ */ new Map());
-        }
-        const e1Attrs = this.linkIndex.get(link.e1);
-        if (!e1Attrs.has(link.a)) {
-          e1Attrs.set(link.a, /* @__PURE__ */ new Set());
-        }
-        e1Attrs.get(link.a).add(link.e2);
-        if (!this.linkReverseIndex.has(link.e2)) {
-          this.linkReverseIndex.set(link.e2, /* @__PURE__ */ new Map());
-        }
-        const e2Attrs = this.linkReverseIndex.get(link.e2);
-        if (!e2Attrs.has(link.a)) {
-          e2Attrs.set(link.a, /* @__PURE__ */ new Set());
-        }
-        e2Attrs.get(link.a).add(link.e1);
-        if (!this.linkAttrIndex.has(link.a)) {
-          this.linkAttrIndex.set(link.a, /* @__PURE__ */ new Set());
-        }
-        this.linkAttrIndex.get(link.a).add([link.e1, link.e2]);
-      }
-      valueKey(v) {
-        if (v instanceof Date) return `date:${v.toISOString()}`;
-        return `${typeof v}:${v}`;
-      }
-      updateCatalog(fact) {
-        const entry = this.catalog.get(fact.a) || {
-          attribute: fact.a,
-          type: this.inferType(fact.v),
-          cardinality: "one",
-          distinctCount: 0,
-          examples: []
-        };
-        const factType = this.inferType(fact.v);
-        if (entry.type !== factType && entry.type !== "mixed") {
-          entry.type = "mixed";
-        }
-        const entityAttrs = this.eavIndex.get(fact.e)?.get(fact.a);
-        if (entityAttrs && entityAttrs.size > 1) {
-          entry.cardinality = "many";
-        }
-        const k = this.valueKey(fact.v);
-        const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, /* @__PURE__ */ new Set()), this.distinct.get(fact.a));
-        s.add(k);
-        entry.distinctCount = s.size;
-        if (entry.examples.length < 5 && !entry.examples.includes(fact.v)) {
-          entry.examples.push(fact.v);
-        }
-        if (typeof fact.v === "number") {
-          entry.min = Math.min(entry.min ?? fact.v, fact.v);
-          entry.max = Math.max(entry.max ?? fact.v, fact.v);
-        }
-        this.catalog.set(fact.a, entry);
-      }
-      inferType(v) {
-        if (typeof v === "string") return "string";
-        if (typeof v === "number") return "number";
-        if (typeof v === "boolean") return "boolean";
-        if (v instanceof Date) return "date";
-        return "mixed";
-      }
-      // Query methods
-      getFactsByEntity(entity) {
-        const indices = this.eavIndex.get(entity);
-        if (!indices) return [];
-        const result = [];
-        for (const attrIndices of indices.values()) {
-          for (const idx of attrIndices) {
-            const fact = this.facts[idx];
-            if (fact) {
-              result.push(fact);
-            }
-          }
-        }
-        return result;
-      }
-      getFactsByAttribute(attribute) {
-        const indices = this.aevIndex.get(attribute);
-        if (!indices) return [];
-        const result = [];
-        for (const entityIndices of indices.values()) {
-          for (const idx of entityIndices) {
-            const fact = this.facts[idx];
-            if (fact) {
-              result.push(fact);
-            }
-          }
-        }
-        return result;
-      }
-      getFactsByValue(attribute, value) {
-        const indices = this.aveIndex.get(attribute)?.get(this.valueKey(value));
-        if (!indices) return [];
-        return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== void 0);
-      }
-      getCatalog() {
-        return Array.from(this.catalog.values());
-      }
-      getCatalogEntry(attribute) {
-        return this.catalog.get(attribute);
-      }
-      // Statistics
-      getAllFacts() {
-        return this.facts.filter((f) => f !== void 0);
-      }
-      getAllLinks() {
-        return [...this.links];
-      }
-      getLinksByEntity(entity) {
-        const results = [];
-        const forwardLinks = this.linkIndex.get(entity);
-        if (forwardLinks) {
-          for (const [attr, targets] of forwardLinks) {
-            for (const target of targets) {
-              results.push({ e1: entity, a: attr, e2: target });
-            }
-          }
-        }
-        const reverseLinks = this.linkReverseIndex.get(entity);
-        if (reverseLinks) {
-          for (const [attr, sources] of reverseLinks) {
-            for (const source of sources) {
-              results.push({ e1: source, a: attr, e2: entity });
-            }
-          }
-        }
-        return results;
-      }
-      getLinksByAttribute(attribute) {
-        const results = [];
-        const links = this.linkAttrIndex.get(attribute);
-        if (links) {
-          for (const [e1, e2] of links) {
-            results.push({ e1, a: attribute, e2 });
-          }
-        }
-        return results;
-      }
-      getLinksByEntityAndAttribute(entity, attribute) {
-        const results = [];
-        const attrs = this.linkIndex.get(entity);
-        if (attrs) {
-          const targets = attrs.get(attribute);
-          if (targets) {
-            for (const target of targets) {
-              results.push({ e1: entity, a: attribute, e2: target });
-            }
-          }
-        }
-        return results;
-      }
-      getStats() {
-        return {
-          totalFacts: this.facts.length,
-          totalLinks: this.links.length,
-          uniqueEntities: this.eavIndex.size,
-          uniqueAttributes: this.aevIndex.size,
-          catalogEntries: this.catalog.size
-        };
-      }
-      /**
-       * Creates a serializable snapshot of the current store state.
-       */
-      snapshot() {
-        return {
-          facts: this.facts.filter((f) => f !== void 0),
-          links: [...this.links],
-          catalog: this.getCatalog()
-        };
-      }
-      /**
-       * Restores the store state from a snapshot and rebuilds all indexes.
-       */
-      restore(snapshot) {
-        this.facts = [];
-        this.links = [];
-        this.catalog.clear();
-        this.eavIndex.clear();
-        this.aevIndex.clear();
-        this.aveIndex.clear();
-        this.linkIndex.clear();
-        this.linkReverseIndex.clear();
-        this.linkAttrIndex.clear();
-        this.distinct.clear();
-        this.addFacts(snapshot.facts);
-        this.addLinks(snapshot.links);
-        if (snapshot.catalog) {
-          for (const entry of snapshot.catalog) {
-            this.catalog.set(entry.attribute, entry);
-          }
-        }
-      }
-    };
-  }
-});
-
-export {
-  flatten,
-  jsonEntityFacts,
-  EAVStore,
-  init_eav_store
-};

package/dist/chunk-GKJLYLVU.js

@@ -1,359 +0,0 @@
-import {
-  TenantPool
-} from "./chunk-VUJQLIML.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;
-  _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-TJHEVSKL.js");
-    const { QueryEngine } = await import("./engine-NSR6BIF7.js");
-    const pool = this._getPool();
-    const tenantId = this.opts.tenantId ?? null;
-    const kernel = pool.get(tenantId);
-    const parsed = parseSimple(eql);
-    const engine = new QueryEngine(kernel.getStore());
-    return engine.execute(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() {
-    this._ws?.close();
-    this._ws = null;
-  }
-  /**
-   * 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;
-  }
-  async _ensureWs() {
-    if (this._ws && this._ws.readyState === WebSocket.OPEN) return this._ws;
-    const opts = this.opts;
-    const wsUrl = opts.url.replace(/^https?/, opts.url.startsWith("https") ? "wss" : "ws") + "/realtime";
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(wsUrl);
-      ws.onopen = () => {
-        this._ws = ws;
-        resolve(ws);
-      };
-      ws.onerror = (e) => reject(e);
-      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 = () => {
-        this._ws = null;
-      };
-    });
-  }
-};
-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
-};