@schemic/surrealdb 0.1.0-alpha.0

package/src/driver/surql-type.ts

@@ -0,0 +1,191 @@
+// The SurrealQL type-expression <-> PortableType bridge (Milestone 2). This is the Surreal driver's
+// `parseType`/`emitType`: it lifts the Struct-IR's `kind` STRING (e.g. `option<int>`,
+// `array<record<user>, 3>`, `'a' | 'b'`) into the dialect-independent PortableType, and renders it
+// back to the canonical SurrealQL spelling (the form `normalizeType` produces). Round-tripping
+// proves the portable model is LOSSLESS for the Surreal dialect — the precondition for flipping diff
+// equality to a structured deep-compare (see docs/MULTI-DB-SPIKE.md, Part 6).
+
+import {
+  array,
+  literal,
+  nullable,
+  option,
+  type PortableType,
+  record,
+  type ScalarName,
+  scalar,
+  union,
+} from "@schemic/core";
+
+const SCALARS = new Set<string>([
+  "any",
+  "bool",
+  "string",
+  "int",
+  "float",
+  "decimal",
+  "number",
+  "datetime",
+  "duration",
+  "uuid",
+  "bytes",
+  "null",
+]);
+
+const GEOMETRY_KINDS = new Set([
+  "feature",
+  "point",
+  "line",
+  "polygon",
+  "multipoint",
+  "multiline",
+  "multipolygon",
+  "collection",
+]);
+
+/** Split a type expression on its top-level `|` (ignoring `|` inside `<…>`). */
+function splitTopUnion(expr: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let cur = "";
+  for (const c of expr) {
+    if (c === "<") depth++;
+    else if (c === ">") depth--;
+    if (c === "|" && depth === 0) {
+      parts.push(cur.trim());
+      cur = "";
+    } else cur += c;
+  }
+  parts.push(cur.trim());
+  return parts;
+}
+
+/** Split `s` once on the first top-level `sep` (outside `<…>`), or null if absent. */
+function topLevelSplitOnce(s: string, sep: string): [string, string] | null {
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "<") depth++;
+    else if (c === ">") depth--;
+    else if (c === sep && depth === 0) return [s.slice(0, i), s.slice(i + 1)];
+  }
+  return null;
+}
+
+/** Parse a (single/double) quoted string literal token, or null if it isn't one. */
+function parseStringLiteral(t: string): string | null {
+  if (t.length >= 2 && (t[0] === "'" || t[0] === '"') && t.at(-1) === t[0]) {
+    const body = t.slice(1, -1);
+    return body.replace(/\\(['"\\])/g, "$1");
+  }
+  return null;
+}
+
+/**
+ * Parse a SurrealQL type expression into a {@link PortableType}. Mirrors the grammar `normalizeType`
+ * canonicalizes: `option<…>`, top-level unions (a `none` member ⇒ `option`, a `null` member ⇒
+ * `nullable`), `array`/`set`/`record`/`references` constructors, literals, and scalars.
+ */
+export function parseSurqlType(kind: string): PortableType {
+  const t = kind.trim();
+
+  // option<X>
+  const opt = /^option<([\s\S]+)>$/.exec(t);
+  if (opt) return option(parseSurqlType(opt[1]));
+
+  // Top-level union: peel `none` (absence) and `null` (null) markers, recurse on the rest.
+  const parts = splitTopUnion(t);
+  if (parts.length > 1) {
+    const hasNone = parts.includes("none");
+    const hasNull = parts.includes("null");
+    const rest = parts.filter((p) => p !== "none" && p !== "null");
+    let inner: PortableType =
+      rest.length === 0 ? { t: "never" } : union(rest.map(parseSurqlType));
+    if (hasNull) inner = nullable(inner);
+    if (hasNone) inner = option(inner);
+    return inner;
+  }
+
+  // Constructor term `ctor<inner>`. `references<…>` (rare) is kept as a Surreal-native escape hatch
+  // so it round-trips losslessly rather than collapsing into `record<…>`.
+  const ctor = /^(array|set|record)<([\s\S]+)>$/.exec(t);
+  if (ctor) {
+    const [, name, innerRaw] = ctor;
+    if (name === "array" || name === "set") {
+      const comma = topLevelSplitOnce(innerRaw, ",");
+      const elem = parseSurqlType(comma ? comma[0] : innerRaw);
+      const size = comma ? Number(comma[1].trim()) : undefined;
+      return name === "array"
+        ? array(elem, Number.isFinite(size) ? size : undefined)
+        : { t: "set", elem, ...(Number.isFinite(size) ? { size } : {}) };
+    }
+    // record<…>: a `|`-list of target tables.
+    const tables = innerRaw
+      .split("|")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    return record(tables);
+  }
+
+  // geometry<point> etc.
+  const geo = /^geometry<([a-z]+)>$/.exec(t);
+  if (geo && GEOMETRY_KINDS.has(geo[1])) {
+    return { t: "geometry", kind: geo[1] as never };
+  }
+
+  // Literals: quoted string, number, boolean.
+  const str = parseStringLiteral(t);
+  if (str !== null) return literal(str);
+  if (/^-?\d+(\.\d+)?$/.test(t)) return literal(Number(t));
+  if (t === "true" || t === "false") return literal(t === "true");
+
+  // Scalars (incl. `null` as a unit type). `none` standalone ⇒ option<never>. `object` ⇒ empty object.
+  if (t === "none") return option({ t: "never" });
+  if (t === "object") return { t: "object", fields: {} };
+  if (SCALARS.has(t)) return scalar(t as ScalarName);
+
+  // Unknown: keep it as a Surreal-native escape hatch rather than losing information.
+  return { t: "native", db: "surreal", name: t };
+}
+
+/** Render a {@link PortableType} back to its canonical SurrealQL spelling (matches `normalizeType`). */
+export function emitSurqlType(p: PortableType): string {
+  switch (p.t) {
+    case "scalar":
+      return p.name;
+    case "literal":
+      return typeof p.value === "string"
+        ? `'${p.value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`
+        : String(p.value);
+    case "option":
+      return `option<${emitSurqlType(p.inner)}>`;
+    case "nullable": {
+      // Canonical: a sorted top-level union with `null` (matches normalizeType, which sorts members
+      // and does not special-case null). `null` sorts before any scalar/ctor name.
+      const inner = emitSurqlType(p.inner);
+      return [inner, "null"].sort().join(" | ");
+    }
+    case "array":
+      return p.size !== undefined
+        ? `array<${emitSurqlType(p.elem)}, ${p.size}>`
+        : `array<${emitSurqlType(p.elem)}>`;
+    case "set":
+      return p.size !== undefined
+        ? `set<${emitSurqlType(p.elem)}, ${p.size}>`
+        : `set<${emitSurqlType(p.elem)}>`;
+    case "union":
+      return [...p.members.map(emitSurqlType)].sort().join(" | ");
+    case "object":
+      return "object";
+    case "record":
+      return `record<${[...p.tables].sort().join(" | ")}>`;
+    case "geometry":
+      return `geometry<${p.kind}>`;
+    case "never":
+      return "none";
+    case "native":
+      return p.name;
+  }
+  // Unreachable: the switch is exhaustive over PortableType["t"].
+  throw new Error(`unhandled portable type: ${(p as { t: string }).t}`);
+}

package/src/driver/surreal.ts

@@ -0,0 +1,364 @@
+// The SURREAL driver — a SET OF KINDS on the core-v2 registry (see docs/kind-registry-flip-plan.md).
+//
+// Everything dialect-specific lives here: the kind `registry` (table/index/event/function/access), the
+// authoring -> kinded `explode`, the single-read `introspectAll`, the connection lifecycle, and the
+// SurrealDB command capabilities. Core orchestrates schema ops (lower/diff/emit/order) GENERICALLY over
+// `registry` — it never names a kind. The Struct-IR (`DbStructured`) + `diffSnapshots` stay the driver's
+// INTERNAL clause-level engine (the kinds delegate to them); the field/type substrate stays core.
+
+import type {
+  ApplyOptions,
+  ConnectionOverrides as CfgOverrides,
+  ConnectionOverrides,
+  Definable,
+  Diff,
+  Driver,
+  Filter,
+  MigrationRecord,
+  MigrationStore,
+  PortableObject,
+  PullPlan,
+  RenderedUnit,
+  ResolvedConfig,
+  ShadowCapability,
+} from "@schemic/core";
+import { registerDriver } from "@schemic/core";
+import { escapeIdent, type Surreal } from "surrealdb";
+import {
+  connectEmbedded,
+  spawnEphemeralServer,
+  surrealBinaryAvailable,
+} from "../cli/engine";
+import {
+  applyStatements,
+  diffAgainstDb,
+  shadowStructured,
+  syncPlan,
+  tsStructsAgainstDb,
+  verifyMigrations,
+} from "../cli/introspect";
+import { planPull, renderPerFile, renderSchemaToTS } from "../cli/pull";
+import { initScaffold, scaffoldEntity } from "../cli/scaffold";
+import { normalizeDb } from "../cli/struct";
+import type { DbStructured } from "../cli/structure";
+import { connect as surrealConnect } from "../cli/surreal-connect";
+import { renderMigration } from "../cli/surreal-diff";
+import { filterStructured } from "../cli/surreal-filter";
+import type { SurrealParams } from "../config";
+import {
+  explodeSchema,
+  fromStructured,
+  introspectAll as introspectAllKinds,
+  toStructured,
+} from "../kinds/explode";
+import type { SurrealPortable } from "../kinds/portable";
+import { surrealKinds } from "../kinds/registry";
+import type { Shape, StandaloneDef, TableDef } from "../pure";
+
+const shadow: ShadowCapability<Surreal> = {
+  // Apply DDL to a throwaway database, read it back via INFO STRUCTURE, drop it — the live-side
+  // canonicalizer. Delegates to `shadowStructured`, then to per-kind portable objects (== lowering).
+  roundTrip: async (conn, config, ddl) =>
+    fromStructured(normalizeDb(await shadowStructured(conn, config, ddl))),
+  // `ephemeral` (full isolated instance for `sz check` replay) is intentionally not wired here —
+  // `check` still uses its existing path. A later milestone routes it through this capability.
+};
+
+// --- migration bookkeeping (the apply-time SurrealQL, moved behind the driver) -------------------
+
+/** Record one applied migration: a `_migrations` row keyed by tag, with file + checksum + time. */
+const RECORD_SQL =
+  "CREATE type::record($tbl, $tag) CONTENT { tag: $tag, file: $file, checksum: $sum, applied_at: time::now() }";
+const recordVars = (table: string, r: MigrationRecord) => ({
+  tbl: table,
+  tag: r.tag,
+  file: r.file,
+  sum: r.checksum,
+});
+
+/** `DEFINE TABLE … SCHEMALESS` for an internal tracking table (migrations or its lock). */
+async function ensureTrackTable(conn: Surreal, table: string): Promise<void> {
+  await conn.query(
+    `DEFINE TABLE IF NOT EXISTS ${escapeIdent(table)} TYPE NORMAL SCHEMALESS PERMISSIONS NONE;`,
+  );
+}
+
+const lockTableOf = (table: string) => `${table}_lock`;
+
+const migrations: MigrationStore<Surreal> = {
+  // SurrealDB migrations are SurrealQL scripts.
+  extension: ".surql",
+  render: (tag, diff) => renderMigration(tag, diff),
+  ensure: ensureTrackTable,
+
+  async applied(conn, table) {
+    const [rows] = await conn.query<[{ tag: string; checksum: string }[]]>(
+      "SELECT tag, checksum FROM type::table($tbl)",
+      { tbl: table },
+    );
+    return new Map((rows ?? []).map((r) => [r.tag, r.checksum]));
+  },
+
+  // SurrealDB is natively transactional — run the migration program + its bookkeeping write in one
+  // BEGIN/COMMIT so the record is written iff the DDL applied. `$direction` drives the up/down branch.
+  async apply(conn, table, { content, direction, record }) {
+    const bookkeep =
+      direction === "up"
+        ? { sql: RECORD_SQL, vars: recordVars(table, record) }
+        : {
+            sql: "DELETE type::record($tbl, $tag)",
+            vars: { tbl: table, tag: record.tag },
+          };
+    await conn.query(`BEGIN;\n${content}\n${bookkeep.sql};\nCOMMIT;`, {
+      direction,
+      ...bookkeep.vars,
+    });
+  },
+
+  async record(conn, table, record) {
+    await ensureTrackTable(conn, table);
+    await conn.query(RECORD_SQL, recordVars(table, record));
+  },
+
+  async clear(conn, table) {
+    await conn.query("DELETE type::table($tbl)", { tbl: table });
+  },
+
+  async lock(conn, table) {
+    const tbl = lockTableOf(table);
+    await ensureTrackTable(conn, tbl);
+    try {
+      await conn.query(
+        "CREATE type::record($tbl, 'lock') CONTENT { at: time::now() }",
+        { tbl },
+      );
+    } catch {
+      throw new Error(
+        "Migrations are locked — another run is in progress. If it's stale, run `schemic unlock`.",
+      );
+    }
+  },
+
+  async unlock(conn, table) {
+    await conn.query("DELETE type::record($tbl, 'lock')", {
+      tbl: lockTableOf(table),
+    });
+  },
+};
+
+/**
+ * Render a structured schema to per-file source: one combined module under `single`, else one file
+ * per object via `fileFor`. Shared by `renderSchema` (offline `diff --ts`) and `diffTsLive`.
+ */
+function renderFiles(
+  struct: DbStructured,
+  fileFor: (kind: string, name: string) => string,
+  single?: string,
+): Map<string, string> {
+  return single
+    ? new Map([[single, renderSchemaToTS(struct)]])
+    : renderPerFile(
+        struct,
+        fileFor as (kind: RenderedUnit["kind"], name: string) => string,
+      );
+}
+
+export const surrealDriver: Driver<
+  Surreal,
+  TableDef<string, Shape>,
+  StandaloneDef
+> = {
+  name: "surrealdb",
+  registry: surrealKinds,
+
+  // --- kind registry (the schema engine) -----------------------------------------------------
+  // Authoring -> kinded definables (the driver-side explode: one inline-authored table fans out into
+  // [table, ...index, ...event], db-level functions/accesses alongside). Core lowers via
+  // `lowerSchema(registry, explode(...))`, then diffs/emits/orders GENERICALLY — it never names a kind.
+  explode: (tables, defs) => explodeSchema(tables, defs),
+  // Live DB -> all portable objects: ONE `INFO … STRUCTURE` read fanned per kind, canonicalized
+  // IDENTICALLY to lowering (a clean apply round-trips to a zero diff) and complete (every kind).
+  introspectAll: (conn, exclude) => introspectAllKinds(conn, exclude),
+
+  // --- execution -----------------------------------------------------------------------------
+
+  connect(
+    config: ResolvedConfig,
+    over?: ConnectionOverrides,
+  ): Promise<Surreal> {
+    // The driver's portable `ConnectionOverrides` is a structural superset of the SDK's; the only
+    // soft field is `authLevel` (a string here vs. the SDK's `AuthLevel` union) — pass it through.
+    return surrealConnect(config, (over ?? {}) as CfgOverrides);
+  },
+
+  async apply(
+    conn: Surreal,
+    statements: string[],
+    opts?: ApplyOptions,
+  ): Promise<void> {
+    if (!statements.length) return;
+    if (opts?.transactional === false) {
+      for (const s of statements) await conn.query(s);
+      return;
+    }
+    // SurrealDB is natively transactional — one BEGIN/COMMIT around the batch (matches applyStatements).
+    await applyStatements(conn, statements);
+  },
+
+  async close(conn: Surreal): Promise<void> {
+    await conn.close();
+  },
+
+  /**
+   * Raw READ query -> rows, for connection resolvers (`ctx.connections.<name>.query(...)`) and seed.
+   * SurrealQL returns one result per statement; we hand back the LAST statement's rows (the payload of
+   * a `… ; SELECT …` resolver), wrapping a scalar/`RETURN` result and treating none as an empty set.
+   */
+  async query<T = unknown>(
+    conn: Surreal,
+    sql: string,
+    vars?: Record<string, unknown>,
+  ): Promise<T[]> {
+    const results = (await conn.query(sql, vars)) as unknown[];
+    if (!results.length) return [];
+    const last = results[results.length - 1];
+    return (Array.isArray(last) ? last : last == null ? [] : [last]) as T[];
+  },
+
+  shadow,
+  migrations,
+
+  // --- command capabilities (thin adapters over the existing surreal cli functions) ----------
+
+  diffLive: (conn, config, filter) => diffAgainstDb(conn, config, filter),
+  syncPlan: (diff, prune) => syncPlan(diff, prune),
+
+  // Offline `diff --ts` / `pull`: reconstruct the structured form from the portable objects (no DDL
+  // re-parse — the normalized struct rides on them), filter, render to per-file `s.*` source.
+  renderSchema(objects, filter, fileFor, single) {
+    return renderFiles(
+      filterStructured(toStructured(objects as SurrealPortable[]), filter),
+      fileFor,
+      single,
+    );
+  },
+
+  // Live `diff --ts`: both sides normalized through SurrealDB, then rendered per file.
+  async diffTsLive(conn, config, filter, fileFor, single) {
+    const { current, desired } = await tsStructsAgainstDb(conn, config, filter);
+    return {
+      current: renderFiles(current, fileFor, single),
+      desired: renderFiles(desired, fileFor, single),
+    };
+  },
+
+  planPull: (conn, config, opts) => planPull(conn, config, opts),
+
+  async serverInfo(conn) {
+    let v = "unknown";
+    try {
+      v = (await conn.version()).version;
+    } catch {
+      // server version unavailable
+    }
+    return `SurrealDB ${v}`;
+  },
+
+  // The files `schemic init` scaffolds for a fresh SurrealDB project (connections-only config + sample
+  // s.* schema + seed + .env.example); the CLI writes them and adds the neutral migration snapshot.
+  initScaffold,
+
+  // `schemic new <kind> <name>`: the starter `s.*`/`define*` module for one entity (table/relation/
+  // view/function/access/event/analyzer); throws for inline-only (index/field) or unknown kinds.
+  scaffoldEntity,
+
+  // `check`: replay every migration into a throwaway engine and diff the result against the schema.
+  // Owns ephemeral-engine selection — an embedded @surrealdb/node instance, an ephemeral server from
+  // the local `surreal` binary, or a configured scratch server — and the replay never touches the
+  // real database. Progress lines go to `log`; the empty/non-empty diff is reported by the caller.
+  async checkReplay(config, over, filter, log) {
+    const params = config.params as unknown as SurrealParams;
+    const check = params.check;
+    const engine = check?.engine ?? "auto";
+    const useBinary =
+      engine === "binary" ||
+      (engine === "auto" && surrealBinaryAvailable(check?.binary));
+    if (engine === "binary" && !useBinary) {
+      throw new Error(
+        'check.engine "binary" needs the `surreal` CLI on PATH (or set `check.binary`). Run `schemic check --schema` to skip the replay.',
+      );
+    }
+
+    let db: Surreal;
+    let checkCfg: ResolvedConfig;
+    let cleanup: () => Promise<void>;
+    if (typeof engine === "object") {
+      const embedded = await connectEmbedded(engine, "check", "check");
+      db = embedded.db;
+      checkCfg = {
+        ...config,
+        params: {
+          url: embedded.url,
+          namespace: "check",
+          database: "check",
+          authLevel: "root",
+        } satisfies SurrealParams,
+      };
+      cleanup = embedded.stop;
+      log(
+        `  replaying on an ${embedded.url} SurrealDB (@surrealdb/node) — no server, your data untouched`,
+      );
+    } else if (useBinary) {
+      const server = await spawnEphemeralServer(check?.binary);
+      checkCfg = {
+        ...config,
+        params: {
+          url: server.url,
+          namespace: "check",
+          database: "check",
+          username: server.username,
+          password: server.password,
+          authLevel: "root",
+        } satisfies SurrealParams,
+      };
+      db = await surrealConnect(checkCfg, {});
+      cleanup = async () => {
+        await db.close().catch(() => {});
+        await server.stop();
+      };
+      log(
+        "  replaying on an ephemeral in-memory SurrealDB (local `surreal` binary) — your server is untouched",
+      );
+    } else {
+      // Scratch connection for the `remote` engine: check.db merged over the connection's own params.
+      const remote: SurrealParams = { ...params, ...(check?.db ?? {}) };
+      checkCfg = {
+        ...config,
+        params: remote as unknown as Record<string, unknown>,
+      };
+      try {
+        db = await surrealConnect(checkCfg, over as CfgOverrides);
+      } catch (e) {
+        throw new Error(
+          `${e instanceof Error ? e.message : String(e)}\n  (run \`schemic check --schema\` to skip the replay, install the \`surreal\` CLI for an in-memory engine, or set \`check.db\` to point the replay at a scratch server)`,
+        );
+      }
+      cleanup = async () => {
+        await db.close().catch(() => {});
+      };
+      log(
+        `  replaying on ${remote.url} (${remote.namespace}) — isolated scratch databases; your data is untouched`,
+      );
+    }
+
+    try {
+      return await verifyMigrations(db, checkCfg, filter, (tag) =>
+        log(`  ${tag}`),
+      );
+    } finally {
+      await cleanup();
+    }
+  },
+};
+
+registerDriver(surrealDriver as Driver<unknown>);

package/src/index.ts

@@ -0,0 +1,99 @@
+/**
+ * @schemic/surrealdb — author SurrealDB schemas with Zod, and the SurrealDB driver.
+ *
+ * Define tables/relations with `s.*` (a drop-in for `z.*`), generate SurrealQL DDL, and map JS <-> DB
+ * across Zod's two channels via codecs (`decode`/`encode`). Importing this package registers the
+ * SurrealDB driver with `@schemic/core` (so the CLI's `getDriver("surrealdb")` resolves).
+ */
+
+// Side-effect: register `surrealDriver` with the core registry on import.
+import "./driver/surreal";
+
+import { type BoundQuery, surql as sdkSurql } from "surrealdb";
+
+/**
+ * Author SurrealQL expressions — the `s.*` authoring API takes these `BoundQuery` values everywhere a
+ * dynamic expression is allowed (`$default`/`$value`/`$computed`/`$assert`, `reference({ onDelete })`,
+ * event `when`/`then`, function bodies, permissions). A thin GENERIC wrapper over the SDK's tag so a
+ * direct SDK query can also carry its RESULT type — one tuple entry per statement:
+ * `db.query(surql<[string[]]>\`RETURN ['a', 'b', 'c']\`)`. Plain `surql\`…\`` (no type arg) is unchanged.
+ * Provided here (typed) so you stay on a single import, decoupled from the SDK version.
+ */
+export function surql<R extends unknown[] = unknown[]>(
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): BoundQuery<R> {
+  return sdkSurql(strings, ...values) as BoundQuery<R>;
+}
+export type { BoundQuery } from "surrealdb";
+/** SurrealDB config types (relocated from @schemic/core/config, now connections-only + dialect-free). */
+export type {
+  AuthLevel,
+  CapabilityList,
+  EmbeddedCapabilities,
+  SurrealParams,
+  SurrealZodCheck,
+  SurrealZodCheckEmbedded,
+  SurrealZodConnection,
+} from "./config";
+export type { SurrealConnectionConfig } from "./connection";
+/** Multi-connection factory: `defineConfig({ connections: { db: surrealConnection({ … }) } })`. */
+export { surrealConnection } from "./connection";
+export type { DefineOptions, DefineStatement, FieldInfo } from "./ddl";
+export {
+  alterField,
+  alterTable,
+  assertExpr,
+  braceBody,
+  emitDefStatement,
+  emitField,
+  emitFieldStatements,
+  emitStatements,
+  emitTable,
+  eventClause,
+  fieldType,
+  inferField,
+  inline,
+  overwriteStatement,
+  removeStatement,
+} from "./ddl";
+export { surrealDriver } from "./driver/surreal";
+export type {
+  AnalyzerConfig,
+  App,
+  Create,
+  DiskannOptions,
+  Expr,
+  FulltextOptions,
+  HnswOptions,
+  Shape,
+  StandaloneDef,
+  SurrealMeta,
+  TableConfig,
+  TableEvent,
+  TableIndex,
+  Update,
+  Wire,
+} from "./pure";
+export {
+  AccessDef,
+  AnalyzerDef,
+  defineAccess,
+  defineAnalyzer,
+  defineEvent,
+  defineFunction,
+  defineRelation,
+  defineTable,
+  defineView,
+  EventDef,
+  FunctionDef,
+  formatForAssert,
+  objectFieldsRegistry,
+  RecordIdField,
+  RelationDef,
+  SField,
+  SystemView,
+  s,
+  surrealTypeRegistry,
+  TableDef,
+} from "./pure";