lakebed 0.0.1

package/src/client.d.ts

@@ -0,0 +1,8 @@
+export type Auth = {
+  userId: string;
+  displayName: string;
+};
+
+export function useAuth(): Auth;
+export function useQuery<T>(name: string): T;
+export function useMutation<TArgs extends unknown[], TResult>(name: string): (...args: TArgs) => Promise<TResult>;

package/src/client.js

@@ -0,0 +1,154 @@
+import { useEffect, useState } from "preact/hooks";
+
+let socket = null;
+let nextRequestId = 1;
+let auth = {
+  userId: "guest:local",
+  displayName: "Local Guest"
+};
+const authListeners = new Set();
+const queryValues = new Map();
+const queryListeners = new Map();
+const pending = new Map();
+const activeSubscriptions = new Set();
+
+function emitAuth() {
+  for (const listener of authListeners) {
+    listener(auth);
+  }
+}
+
+function emitQuery(name, value) {
+  queryValues.set(name, value);
+  const listeners = queryListeners.get(name);
+  if (!listeners) {
+    return;
+  }
+
+  for (const listener of listeners) {
+    listener(value);
+  }
+}
+
+function send(message) {
+  const ws = connect();
+  const payload = JSON.stringify(message);
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(payload);
+    return;
+  }
+
+  ws.addEventListener(
+    "open",
+    () => {
+      ws.send(payload);
+    },
+    { once: true }
+  );
+}
+
+function request(op, payload) {
+  const id = nextRequestId++;
+  send({ id, op, ...payload });
+
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+  });
+}
+
+function connect() {
+  if (socket && socket.readyState !== WebSocket.CLOSED && socket.readyState !== WebSocket.CLOSING) {
+    return socket;
+  }
+
+  const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+  const basePath = window.__LAKEBED_BASE_PATH__ ?? "";
+  const url = new URL(`${protocol}//${window.location.host}${basePath}/__lakebed/ws`);
+  const guestName = new URLSearchParams(window.location.search).get("lakebed_guest");
+  if (guestName) {
+    url.searchParams.set("lakebed_guest", guestName);
+  }
+
+  socket = new WebSocket(url);
+
+  socket.addEventListener("open", () => {
+    send({ op: "auth.get" });
+    for (const name of activeSubscriptions) {
+      send({ op: "query.subscribe", name });
+    }
+  });
+
+  socket.addEventListener("message", (event) => {
+    const message = JSON.parse(String(event.data));
+
+    if (message.op === "auth.result") {
+      auth = message.auth;
+      emitAuth();
+      return;
+    }
+
+    if (message.op === "query.result") {
+      emitQuery(message.name, message.data);
+      return;
+    }
+
+    if (message.id && pending.has(message.id)) {
+      const handlers = pending.get(message.id);
+      pending.delete(message.id);
+
+      if (message.ok) {
+        handlers.resolve(message.result);
+      } else {
+        handlers.reject(new Error(message.error ?? "Lakebed request failed"));
+      }
+    }
+  });
+
+  socket.addEventListener("close", () => {
+    window.setTimeout(() => {
+      socket = null;
+      connect();
+    }, 500);
+  });
+
+  return socket;
+}
+
+export function useAuth() {
+  const [value, setValue] = useState(auth);
+
+  useEffect(() => {
+    connect();
+    authListeners.add(setValue);
+    return () => {
+      authListeners.delete(setValue);
+    };
+  }, []);
+
+  return value;
+}
+
+export function useQuery(name) {
+  const [value, setValue] = useState(queryValues.get(name) ?? []);
+
+  useEffect(() => {
+    connect();
+    activeSubscriptions.add(name);
+    if (!queryListeners.has(name)) {
+      queryListeners.set(name, new Set());
+    }
+
+    queryListeners.get(name).add(setValue);
+    send({ op: "query.subscribe", name });
+
+    return () => {
+      queryListeners.get(name)?.delete(setValue);
+    };
+  }, [name]);
+
+  return value;
+}
+
+export function useMutation(name) {
+  return (...args) => request("mutation.run", { name, args });
+}

package/src/runtime.js

@@ -0,0 +1,252 @@
+import { randomUUID } from "node:crypto";
+
+function now() {
+  return new Date().toISOString();
+}
+
+function compareValues(left, right) {
+  if (left === right) {
+    return 0;
+  }
+
+  return left > right ? 1 : -1;
+}
+
+class QueryBuilder {
+  constructor(table, rows, filters = [], sort = null, max = null) {
+    this.table = table;
+    this.rows = rows;
+    this.filters = filters;
+    this.sort = sort;
+    this.max = max;
+  }
+
+  where(field, value) {
+    return new QueryBuilder(this.table, this.rows, [...this.filters, { field, value }], this.sort, this.max);
+  }
+
+  orderBy(field, direction = "asc") {
+    return new QueryBuilder(this.table, this.rows, this.filters, { field, direction }, this.max);
+  }
+
+  limit(count) {
+    return new QueryBuilder(this.table, this.rows, this.filters, this.sort, count);
+  }
+
+  all() {
+    let results = Array.from(this.rows.values());
+
+    for (const filter of this.filters) {
+      results = results.filter((row) => row[filter.field] === filter.value);
+    }
+
+    if (this.sort) {
+      const direction = this.sort.direction === "desc" ? -1 : 1;
+      results = [...results].sort((left, right) => compareValues(left[this.sort.field], right[this.sort.field]) * direction);
+    }
+
+    if (typeof this.max === "number") {
+      results = results.slice(0, this.max);
+    }
+
+    return results.map((row) => ({ ...row }));
+  }
+}
+
+function metadataFields() {
+  return new Set(["id", "createdAt", "updatedAt"]);
+}
+
+function fieldDefault(field) {
+  if (!field || !Object.prototype.hasOwnProperty.call(field, "defaultValue")) {
+    return undefined;
+  }
+
+  return typeof field.defaultValue === "function" ? field.defaultValue() : field.defaultValue;
+}
+
+function assertFieldValue(tableName, fieldName, field, value) {
+  if (value === undefined) {
+    throw new Error(`Missing value for ${tableName}.${fieldName}`);
+  }
+
+  if (field.kind === "string" && typeof value !== "string") {
+    throw new Error(`Expected ${tableName}.${fieldName} to be a string.`);
+  }
+
+  if (field.kind === "boolean" && typeof value !== "boolean") {
+    throw new Error(`Expected ${tableName}.${fieldName} to be a boolean.`);
+  }
+}
+
+class TableApi extends QueryBuilder {
+  constructor(stateCell, name) {
+    const rows = stateCell.tables.get(name);
+    super(name, rows);
+    this.stateCell = stateCell;
+    this.name = name;
+    this.definition = stateCell.schema?.[name];
+  }
+
+  validateInsert(value) {
+    const fields = this.definition?.fields ?? {};
+    const metadata = metadataFields();
+
+    for (const key of Object.keys(value)) {
+      if (!fields[key] && !metadata.has(key)) {
+        throw new Error(`Unknown field for ${this.name}: ${key}`);
+      }
+
+      if (metadata.has(key)) {
+        throw new Error(`Lakebed manages ${this.name}.${key}; app code cannot set it directly.`);
+      }
+    }
+
+    const row = {};
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const valueOrDefault = value[fieldName] ?? fieldDefault(field);
+      assertFieldValue(this.name, fieldName, field, valueOrDefault);
+      row[fieldName] = valueOrDefault;
+    }
+
+    return row;
+  }
+
+  validatePatch(patch) {
+    const fields = this.definition?.fields ?? {};
+    const metadata = metadataFields();
+    const cleanPatch = {};
+
+    for (const [key, value] of Object.entries(patch)) {
+      if (!fields[key] && !metadata.has(key)) {
+        throw new Error(`Unknown field for ${this.name}: ${key}`);
+      }
+
+      if (metadata.has(key)) {
+        throw new Error(`Lakebed manages ${this.name}.${key}; app code cannot update it directly.`);
+      }
+
+      assertFieldValue(this.name, key, fields[key], value);
+      cleanPatch[key] = value;
+    }
+
+    return cleanPatch;
+  }
+
+  get(id) {
+    const row = this.rows.get(id);
+    return row ? { ...row } : null;
+  }
+
+  insert(value) {
+    const timestamp = now();
+    const fields = this.validateInsert(value);
+    const row = {
+      ...fields,
+      id: randomUUID(),
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    this.rows.set(row.id, row);
+    this.stateCell.changedTables.add(this.name);
+    return { ...row };
+  }
+
+  update(id, patch) {
+    const row = this.rows.get(id);
+    if (!row) {
+      return;
+    }
+
+    const cleanPatch = this.validatePatch(patch);
+    this.rows.set(id, {
+      ...row,
+      ...cleanPatch,
+      id,
+      updatedAt: now()
+    });
+    this.stateCell.changedTables.add(this.name);
+  }
+
+  delete(id) {
+    if (this.rows.delete(id)) {
+      this.stateCell.changedTables.add(this.name);
+    }
+  }
+}
+
+export class StateCell {
+  constructor(schema) {
+    this.schema = schema;
+    this.tables = new Map();
+    this.changedTables = new Set();
+    this.queue = Promise.resolve();
+
+    for (const tableName of Object.keys(schema ?? {})) {
+      this.tables.set(tableName, new Map());
+    }
+  }
+
+  createDb() {
+    const db = {};
+    for (const tableName of this.tables.keys()) {
+      db[tableName] = new TableApi(this, tableName);
+    }
+    return db;
+  }
+
+  listTables() {
+    return Array.from(this.tables.keys()).sort();
+  }
+
+  dump() {
+    const tables = {};
+    for (const [tableName, rows] of this.tables) {
+      tables[tableName] = Array.from(rows.values()).map((row) => ({ ...row }));
+    }
+
+    return { tables };
+  }
+
+  async transaction(handler) {
+    const run = async () => {
+      this.changedTables.clear();
+      const result = await handler(this.createDb());
+      const changedTables = Array.from(this.changedTables);
+      this.changedTables.clear();
+      return { result, changedTables };
+    };
+
+    const next = this.queue.then(run, run);
+    this.queue = next.then(
+      () => undefined,
+      () => undefined
+    );
+    return next;
+  }
+}
+
+export class LogBuffer {
+  constructor() {
+    this.entries = [];
+  }
+
+  append(level, message, data) {
+    const entry = {
+      level,
+      message,
+      data,
+      at: now()
+    };
+    this.entries.push(entry);
+    console[level === "error" ? "error" : level === "warn" ? "warn" : "log"](`[lakebed:${level}] ${message}`, data ?? "");
+  }
+
+  createLogger() {
+    return {
+      info: (message, data) => this.append("info", message, data),
+      warn: (message, data) => this.append("warn", message, data),
+      error: (message, data) => this.append("error", message, data)
+    };
+  }
+}

package/src/server.d.ts

@@ -0,0 +1,53 @@
+export type Field<T> = {
+  kind: string;
+  defaultValue?: T;
+  default(value: T): Field<T>;
+};
+
+export type TableDefinition = {
+  kind: "table";
+  fields: Record<string, Field<unknown>>;
+};
+
+export type AuthContext = {
+  userId: string;
+  displayName: string;
+};
+
+export type LogContext = {
+  info(message: string, data?: unknown): void;
+  warn(message: string, data?: unknown): void;
+  error(message: string, data?: unknown): void;
+};
+
+export type QueryBuilder<T> = {
+  where(field: keyof T & string, value: unknown): QueryBuilder<T>;
+  orderBy(field: keyof T & string, direction?: "asc" | "desc"): QueryBuilder<T>;
+  limit(count: number): QueryBuilder<T>;
+  all(): Array<T & { id: string; createdAt: string; updatedAt: string }>;
+};
+
+export type TableApi<T> = QueryBuilder<T> & {
+  get(id: string): (T & { id: string; createdAt: string; updatedAt: string }) | null;
+  insert(value: T): T & { id: string; createdAt: string; updatedAt: string };
+  update(id: string, patch: Partial<T>): void;
+  delete(id: string): void;
+};
+
+export type DbContext = Record<string, TableApi<Record<string, unknown>>>;
+
+export type ServerContext = {
+  auth: AuthContext;
+  db: DbContext;
+  env: Record<string, string | undefined>;
+  log: LogContext;
+};
+
+export function capsule<T>(definition: T): T;
+export function query<T>(handler: (ctx: ServerContext) => T): (ctx: ServerContext) => T;
+export function mutation<TArgs extends unknown[], TResult>(
+  handler: (ctx: ServerContext, ...args: TArgs) => TResult
+): (ctx: ServerContext, ...args: TArgs) => TResult;
+export function table(fields: Record<string, Field<unknown>>): TableDefinition;
+export function string(): Field<string>;
+export function boolean(): Field<boolean>;

package/src/server.js

@@ -0,0 +1,39 @@
+export function capsule(definition) {
+  return definition;
+}
+
+export function query(handler) {
+  return handler;
+}
+
+export function mutation(handler) {
+  return handler;
+}
+
+function field(kind) {
+  return {
+    kind,
+    defaultValue: undefined,
+    default(value) {
+      return {
+        ...this,
+        defaultValue: value
+      };
+    }
+  };
+}
+
+export function table(fields) {
+  return {
+    kind: "table",
+    fields
+  };
+}
+
+export function string() {
+  return field("string");
+}
+
+export function boolean() {
+  return field("boolean");
+}

package/src/source-store.js

@@ -0,0 +1,110 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { posix } from "node:path";
+import { randomUUID } from "node:crypto";
+
+function normalizePath(path) {
+  return path.replaceAll("\\", "/").replace(/^\/+/, "").replace(/\/+/g, "/");
+}
+
+async function readDirectory(rootDir, dir = rootDir, files = new Map()) {
+  const entries = await readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".lakebed" || entry.name === ".DS_Store") {
+      continue;
+    }
+
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await readDirectory(rootDir, absolutePath, files);
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const storePath = normalizePath(relative(rootDir, absolutePath).split(sep).join("/"));
+    files.set(storePath, await readFile(absolutePath, "utf8"));
+  }
+
+  return files;
+}
+
+export class MemorySourceStore {
+  constructor(files = new Map(), snapshots = new Map()) {
+    this.files = new Map(files);
+    this.snapshots = new Map(snapshots);
+    this.archived = false;
+  }
+
+  clone() {
+    return new MemorySourceStore(this.files, this.snapshots);
+  }
+
+  hasFile(path) {
+    return this.files.has(normalizePath(path));
+  }
+
+  async readFile(path) {
+    const normalized = normalizePath(path);
+    const contents = this.files.get(normalized);
+    if (contents === undefined) {
+      throw new Error(`Source file not found: ${normalized}`);
+    }
+
+    return contents;
+  }
+
+  async writeFile(path, contents) {
+    if (this.archived) {
+      throw new Error("Cannot write to an archived source store.");
+    }
+
+    this.files.set(normalizePath(path), contents);
+  }
+
+  async listFiles(root = "") {
+    const normalizedRoot = normalizePath(root);
+    return Array.from(this.files.keys())
+      .filter((path) => path === normalizedRoot || path.startsWith(normalizedRoot ? `${normalizedRoot}/` : ""))
+      .sort();
+  }
+
+  async snapshot(message = "") {
+    const id = randomUUID();
+    this.snapshots.set(id, {
+      id,
+      message,
+      at: new Date().toISOString(),
+      files: new Map(this.files)
+    });
+    return id;
+  }
+
+  async fork(snapshotId) {
+    const snapshot = this.snapshots.get(snapshotId);
+    if (!snapshot) {
+      throw new Error(`Unknown source snapshot: ${snapshotId}`);
+    }
+
+    return new MemorySourceStore(snapshot.files, this.snapshots);
+  }
+
+  async archive() {
+    this.archived = true;
+  }
+}
+
+export async function createMemorySourceStoreFromDirectory(rootDir) {
+  return new MemorySourceStore(await readDirectory(rootDir));
+}
+
+export function sourcePathJoin(...parts) {
+  return normalizePath(posix.join(...parts));
+}
+
+export function sourcePathDirname(path) {
+  return normalizePath(posix.dirname(normalizePath(path)));
+}