trellis 1.0.6 → 1.0.8

package/dist/kernel/workspace.js

@@ -0,0 +1,91 @@
+// src/kernel/workspace.ts
+import { z } from "zod";
+var PropertyTypeSchema = z.enum([
+  "title",
+  "rich_text",
+  "number",
+  "select",
+  "multi_select",
+  "status",
+  "date",
+  "people",
+  "files",
+  "checkbox",
+  "url",
+  "email",
+  "phone_number",
+  "relation",
+  "rollup",
+  "formula",
+  "ai_generated"
+]);
+var PropertyValueSpecificationSchema = z.object({
+  name: z.string(),
+  valueType: PropertyTypeSchema,
+  required: z.boolean().optional(),
+  description: z.string().optional(),
+  selectOptions: z.array(z.any()).optional(),
+  relation: z.object({
+    targetSchema: z.string().optional(),
+    cardinality: z.enum(["one", "many"]).optional(),
+    syncedProperty: z.string().optional()
+  }).optional(),
+  formula: z.string().optional(),
+  rollup: z.object({
+    relationProperty: z.string(),
+    targetProperty: z.string(),
+    aggregation: z.enum([
+      "count",
+      "sum",
+      "avg",
+      "min",
+      "max",
+      "median",
+      "mode"
+    ])
+  }).optional(),
+  aiGenerated: z.object({
+    prompt: z.string(),
+    model: z.string().optional()
+  }).optional()
+});
+var SchemaDefinitionSchema = z.object({
+  "@id": z.string(),
+  "@type": z.literal("trellis:Schema"),
+  version: z.string(),
+  fields: z.array(PropertyValueSpecificationSchema)
+});
+var ProjectionDefinitionSchema = z.object({
+  "@id": z.string(),
+  "@type": z.literal("trellis:Projection"),
+  name: z.string(),
+  type: z.enum([
+    "card-grid",
+    "table",
+    "timeline",
+    "dashboard",
+    "kanban",
+    "graph"
+  ]),
+  query: z.string(),
+  config: z.record(z.string(), z.any()).optional()
+});
+var WorkspaceConfigSchema = z.object({
+  workspace: z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    ontologies: z.record(z.string(), SchemaDefinitionSchema).optional(),
+    graph: z.object({
+      nodes: z.array(z.any()).optional(),
+      edges: z.array(z.any()).optional()
+    }).optional(),
+    projections: z.record(z.string(), ProjectionDefinitionSchema).optional()
+  })
+});
+export {
+  WorkspaceConfigSchema,
+  SchemaDefinitionSchema,
+  PropertyValueSpecificationSchema,
+  PropertyTypeSchema,
+  ProjectionDefinitionSchema
+};

package/dist/persist/sqlite-backend.js

@@ -0,0 +1,123 @@
+// src/persist/sqlite-backend.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var encodeAtom = (v) => {
+  if (v instanceof Date)
+    return { $type: "date", value: v.toISOString() };
+  return v;
+};
+var decodeAtom = (v) => {
+  if (v && typeof v === "object" && "$type" in v && v.$type === "date" && typeof v.value === "string") {
+    return new Date(v.value);
+  }
+  return v;
+};
+var encodeOp = (op) => {
+  const encoded = { ...op };
+  if (encoded.facts) {
+    encoded.facts = encoded.facts.map((f) => ({
+      ...f,
+      v: encodeAtom(f.v)
+    }));
+  }
+  return encoded;
+};
+var decodeOp = (raw) => {
+  const decoded = { ...raw };
+  if (decoded.facts) {
+    decoded.facts = decoded.facts.map((f) => ({
+      ...f,
+      v: decodeAtom(f.v)
+    }));
+  }
+  return decoded;
+};
+
+class SqliteKernelBackend {
+  opts;
+  db;
+  constructor(opts) {
+    this.opts = opts;
+    const mod = require2(["bun", "sqlite"].join(":"));
+    const DatabaseCtor = mod?.Database;
+    if (!DatabaseCtor) {
+      throw new Error("bun:sqlite is not available in this runtime");
+    }
+    this.db = new DatabaseCtor(opts.filename);
+  }
+  init() {
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS ops (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        hash TEXT NOT NULL UNIQUE,
+        ts INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        payload TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_ops_hash ON ops(hash);
+
+      CREATE TABLE IF NOT EXISTS snapshots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        last_op_hash TEXT NOT NULL,
+        ts INTEGER NOT NULL,
+        data TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_snapshots_ts ON snapshots(ts);
+    `);
+  }
+  append(op) {
+    const stmt = this.db.prepare("INSERT INTO ops (hash, ts, kind, payload) VALUES (?, ?, ?, ?)");
+    stmt.run(op.hash, new Date(op.timestamp).getTime(), op.kind, JSON.stringify(encodeOp(op)));
+  }
+  readAll() {
+    const rows = this.db.prepare("SELECT payload FROM ops ORDER BY id ASC").all();
+    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
+  }
+  readUntil(hash) {
+    const target = this.db.prepare("SELECT id FROM ops WHERE hash = ?").get(hash);
+    if (!target) {
+      throw new Error(`Operation with hash ${hash} not found`);
+    }
+    const rows = this.db.prepare("SELECT payload FROM ops WHERE id <= ? ORDER BY id ASC").all(target.id);
+    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
+  }
+  readAfter(hash) {
+    const target = this.db.prepare("SELECT id FROM ops WHERE hash = ?").get(hash);
+    if (!target) {
+      throw new Error(`Operation with hash ${hash} not found`);
+    }
+    const rows = this.db.prepare("SELECT payload FROM ops WHERE id > ? ORDER BY id ASC").all(target.id);
+    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
+  }
+  readUntilTimestamp(isoTimestamp) {
+    const ts = new Date(isoTimestamp).getTime();
+    const rows = this.db.prepare("SELECT payload FROM ops WHERE ts <= ? ORDER BY id ASC").all(ts);
+    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
+  }
+  getLastOp() {
+    const row = this.db.prepare("SELECT payload FROM ops ORDER BY id DESC LIMIT 1").get();
+    if (!row)
+      return;
+    return decodeOp(JSON.parse(row.payload));
+  }
+  saveSnapshot(lastOpHash, data) {
+    const stmt = this.db.prepare("INSERT INTO snapshots (last_op_hash, ts, data) VALUES (?, ?, ?)");
+    stmt.run(lastOpHash, Date.now(), JSON.stringify(data));
+  }
+  loadLatestSnapshot() {
+    const row = this.db.prepare("SELECT last_op_hash, data FROM snapshots ORDER BY ts DESC LIMIT 1").get();
+    if (!row)
+      return;
+    return {
+      lastOpHash: row.last_op_hash,
+      data: JSON.parse(row.data)
+    };
+  }
+  close() {
+    this.db.close();
+  }
+}
+export {
+  SqliteKernelBackend
+};