@sanoma-ai/workflows 0.1.0 → 0.4.0

package/src/config.ts

@@ -2,10 +2,22 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { type ApplyDeclared, applyWorkflow } from "./apply.ts";
+import { applySteps } from "./apply-steps.ts";
+import { callWorkflow } from "./call-workflow.ts";
+import {
+  type Collection,
+  collectionsConnector,
+  collectionsDriver,
+  collectionsFake,
+  isCollection,
+} from "./collection.ts";
+import { lazyPool, type LazyPool } from "./db.ts";
 import { callerFile, type Use, type WorkflowDefinition } from "./define.ts";
-import { DRIFT_WORKFLOW, type DriftDeclared, driftWorkflow } from "./drift.ts";
+import { DRIFT_WORKFLOW, driftWorkflow } from "./drift.ts";
 import { statusesOf, unconfigured } from "./env.ts";
 import type { Fake } from "./fake.ts";
+import { peopleConnector } from "./person.ts";
 import type { LedgerStore } from "./ledger.ts";
 import {
   type Connector,
@@ -20,17 +32,20 @@ import {
   setupOf,
   VENDOR,
 } from "./op.ts";
+import { policyAt } from "./cedar.ts";
 import type { Policy } from "./policy.ts";
-import { type Resource, resourceTypesOf, withoutWriteOnly } from "./resource.ts";
+import { isChangeOp, type Resource, resourceTypesOf, withoutWriteOnly } from "./resource.ts";
+import { APPLY_WORKFLOW, BUILT_IN_WORKFLOWS, CALL_WORKFLOW, DATA_VENDOR } from "./shared.ts";
+import { sourceDriver, sourceOps } from "./source.ts";
 import type { Steps } from "./steps.ts";
 import { computeVersion } from "./version.ts";
 
 /**
- * What a worker runs, on which connectors, under which policy: the argument to `startWorker`.
+ * What a worker runs, on which connectors: the argument to `startWorker`.
  * A project usually keeps it in `sanoma.config.ts` and passes it in; nothing loads that file
  * automatically. The rest is convention: each connector carries its driver and its fake
- * (`withSetup`), the app's name is its `package.json`'s, and the scenarios and data files are
- * `scenarios/` and `resources/` in `root`.
+ * (`withSetup`), the app's name is its `package.json`'s, and the scenarios, data files and
+ * policies are `scenarios/`, `resources/` and `policies/` in `root`.
  */
 export interface SanomaConfig {
   workflows: WorkflowDefinition<any, any>[];
@@ -42,8 +57,6 @@ export interface SanomaConfig {
    * package attaches the maker of.
    */
   connectors: Connector<any, any>[];
-  /** Checked before every operation call. Required: `allowAll` says that every call is allowed. */
-  policy: Policy;
   /**
    * Where the audit record goes. Default: `postgresLedger` on the config's database, which the
    * worker, the app and other processes share; the worker and the client each make their own
@@ -70,8 +83,15 @@ export interface SanomaConfig {
   appName?: never;
   /** @deprecated Gone: the scenarios are `<root>/scenarios/`. Leave it out. */
   scenarios?: never;
+  /** @deprecated Gone: the policy is `<root>/policies/**\/*.cedar`. Leave it out. */
+  policy?: never;
   /** The company's own steps for its scenarios (`defineSteps`), besides those its connectors ship. */
   steps?: Steps[];
+  /**
+   * The company's collections (`collection()`): their operations are `data.<name>.<op>`, their
+   * records in the config's database, and in memory for a sandbox run.
+   */
+  collections?: readonly Collection[];
 }
 
 /** A config, checked, with everything a worker, client or app derives from it. */
@@ -86,7 +106,10 @@ export interface ResolvedConfig {
   version: string;
   /** The DBOS queue runs are started on: `sanoma:<appName>`. */
   queueName: string;
-  /** The operations the connectors declare, by id. */
+  /**
+   * The operations the connectors declare, by id, the built-in `sanoma.source.resolve` when one
+   * declares a host type, and the collections' (`data.<name>.<op>`).
+   */
   ops: Map<string, Op>;
   /** The drivers' functions, by operation id, each guarded by its driver's `env` (`indexDrivers`). */
   drivers: Map<string, DriverFn>;
@@ -103,12 +126,27 @@ export interface ResolvedConfig {
   types: ReadonlyMap<string, Resource>;
   /** The steps scenarios can use besides the generic ones: each connector's (`withSetup`), once each, then the config's own. */
   steps: readonly Steps[];
+  /** The config's collections, by name: their operations are in `ops` and `drivers`, their fake in `fakes`, under `DATA_VENDOR`. */
+  collections: ReadonlyMap<string, Collection>;
+  /**
+   * The pool the collections' driver keeps their records through, when there are any: opened on
+   * its first call, and closed by whoever calls the driver (the worker, and the client, which
+   * calls it directly, when each stops).
+   */
+  dataStore?: LazyPool;
   /**
-   * By name; each checked against `ops` and `drivers`. The config's, and the built-in `drift`
-   * (`DRIFT_WORKFLOW`) when its connectors declare resource types.
+   * By name; each checked against `ops` and `drivers`. The config's, the built-ins `drift`
+   * (`DRIFT_WORKFLOW`) and `apply` (`APPLY_WORKFLOW`) when its connectors declare resource types,
+   * and `call` (`CALL_WORKFLOW`) when an operation may be called directly (`isDirect`).
    */
   workflows: Map<string, WorkflowDefinition<any, any>>;
+  /**
+   * Checked before every operation call and run start: the root's `policies/**\/*.cedar`
+   * (`policyAt`), `allowAll` without any, and one that refuses everything while they have problems.
+   */
   policy: Policy;
+  /** What is wrong in the policies, one printable line each (`file:line:col: <policy id>: <message>`). */
+  policyProblems: string[];
   /** The config's `ledger`, when it gives one; the worker and the client otherwise make `postgresLedger` on `databaseUrl` (`ownedLedger`). */
   ledger?: LedgerStore;
   /**
@@ -158,12 +196,13 @@ export function rootOf(config: Pick<SanomaConfig, "root" | "file">): string | un
 
 /**
  * Checks a config and derives what the runtime needs from it: the drivers and fakes from the
- * connectors' setups (`withSetup`), and from `root`, the app's name (`package.json`) and the
- * scenarios (`scenarios/`). Throws what `startWorker` would refuse, with the same message, so
- * `describeConfig`, `SanomaClient.connect` and the app fail the same way the worker does. It
- * opens nothing and reads no file outside `root`. Each entry
- * point resolves once: the worker and the client when they start, the app at `startApp`, the
- * `sanoma` bin when it loads the config.
+ * connectors' setups (`withSetup`), the collections' operations, driver and fake, and from
+ * `root`, the app's name (`package.json`), the scenarios (`scenarios/`) and the policy
+ * (`policies/`, `policyAt`). Throws what
+ * `startWorker` would refuse, with the same message, so `describeConfig`, `SanomaClient.connect`
+ * and the app fail the same way the worker does. It opens nothing and reads no file outside
+ * `root`. Each entry point resolves once: the worker and the client when they start, the app at
+ * `startApp`, the `sanoma` bin when it loads the config.
  */
 export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   if (!Array.isArray(config.connectors)) {
@@ -173,30 +212,49 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   if (!Array.isArray(config.workflows)) {
     throw new Error("The config needs `workflows`: an array of defineWorkflow definitions");
   }
-  if (typeof config.policy !== "function") {
-    throw new Error("The config needs a `policy`; use `allowAll` to allow every operation call");
-  }
   // An untyped config naming fake drivers would otherwise run live. Delete once sanoma-ops has migrated.
   if (config.drivers !== undefined || config.fakes !== undefined)
     throw new Error(
       "The config's `drivers` and `fakes` are gone: each connector carries its driver and its fake; leave them out",
     );
+  // An untyped config naming its policy would otherwise run allowing everything. Delete once sanoma-ops has migrated.
+  if (config.policy !== undefined) {
+    throw new Error("The config's `policy` is gone: the policy is policies/*.cedar in the root; leave it out");
+  }
+  const collections = collectionsOf(config);
   const ledger = ledgerOf(config);
   const root = rootOf(config);
   const appName = appNameAt(root);
   const scenarios = scenariosAt(root);
-  const ops = indexConnectors(config.connectors);
+  const types = resourceTypesOf(config.connectors);
+  // Built-in: `sanoma.source.resolve`, which apply and drift call for a host's revision.
+  const hosts = [...types.values()].some((type) => type.host);
+  // Built-in: the collections' operations, `data.<name>.<op>`, on the config's database.
+  const databaseUrl = resolveDatabaseUrl(config);
+  const declared = [...collections.values()];
+  const dataStore = declared.length ? lazyPool(databaseUrl, "data") : undefined;
+  const ops = indexConnectors([
+    ...config.connectors,
+    ...(hosts ? [sourceOps] : []),
+    ...(dataStore ? [collectionsConnector(declared)] : []),
+  ]);
   const driversByVendor = new Map([...makersOf(config.connectors, "driver")].map(([vendor, make]) => [vendor, make()]));
-  const drivers = indexDrivers([...driversByVendor.values()], ops);
+  const drivers = indexDrivers(
+    [
+      ...driversByVendor.values(),
+      ...(hosts ? [sourceDriver] : []),
+      ...(dataStore ? [collectionsDriver(declared, dataStore)] : []),
+    ],
+    ops,
+  );
   const fakes = makersOf(config.connectors, "fake");
+  if (dataStore) fakes.set(DATA_VENDOR, () => collectionsFake(declared));
   const names = new Map<string, WorkflowDefinition<any, any>>();
   for (const wf of config.workflows) {
-    if (wf.name === DRIFT_WORKFLOW) {
-      throw new Error(
-        `A workflow is named "${DRIFT_WORKFLOW}", the name of the built-in drift workflow; name it otherwise`,
-      );
+    if (BUILT_IN_WORKFLOWS.has(wf.name)) {
+      throw new Error(`A workflow is named "${wf.name}", the name of a built-in workflow; name it otherwise`);
     }
-    checkUses(wf, ops, drivers);
+    checkUses(wf, ops, drivers, types);
     const other = names.get(wf.name);
     if (other && other !== wf) {
       throw new Error(
@@ -205,16 +263,25 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
     }
     names.set(wf.name, wf);
   }
-  // Built-in: checking the resources the data files declare against their vendors.
-  const types = resourceTypesOf(config.connectors);
+  // Built-in: checking the resources the data files declare against their vendors, and applying them.
   if (types.size) {
-    const declared = () =>
-      DBOS.runStep(() => readDeclared(root, config.connectors, types), { name: "drift:data-files" });
-    names.set(DRIFT_WORKFLOW, driftWorkflow(types, ops, drivers, declared));
+    const connectors = connectorsOf(config);
+    // The types the data files may declare: the vendors' and the people's, whose resources are left out.
+    const declarable = resourceTypesOf(connectors);
+    const read = () => readDeclared(root, connectors, declarable, types);
+    names.set(
+      DRIFT_WORKFLOW,
+      driftWorkflow(types, ops, drivers, () => DBOS.runStep(read, { name: "drift:data-files" })),
+    );
+    names.set(APPLY_WORKFLOW, applyWorkflow(types, ops, drivers, applySteps(appName, root, read)));
   }
+  // Built-in: a direct call the policy holds for an approval, made a run, when any operation may be called directly.
+  const call = callWorkflow(ops, drivers, types);
+  if (call.uses.length) names.set(CALL_WORKFLOW, call);
+  const { policy, problems: policyProblems } = policyAt(root, { ops, workflows: names, collections });
   return {
     appName,
-    databaseUrl: resolveDatabaseUrl(config),
+    databaseUrl,
     // The built-in's code and operations are part of the app's version, like the config's own.
     version: computeVersion({ appName, workflows: [...names.values()] }),
     queueName: `sanoma:${appName}`,
@@ -225,13 +292,46 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
     ...(scenarios && { scenarios }),
     types,
     steps: [...new Set([...config.connectors.flatMap((c) => setupOf(c).steps ?? []), ...(config.steps ?? [])])],
+    collections,
+    ...(dataStore && { dataStore }),
     workflows: names,
-    policy: config.policy,
+    policy,
+    policyProblems,
     ...(ledger !== undefined && { ledger }),
     ...(root !== undefined && { root }),
   };
 }
 
+/**
+ * The config's collections by name, checked: each one `collection()` made, no two with one name,
+ * and no connector of their vendor, `DATA_VENDOR`.
+ */
+function collectionsOf(config: SanomaConfig): Map<string, Collection> {
+  const list: unknown = config.collections ?? [];
+  if (!Array.isArray(list)) {
+    throw new Error("The config's `collections` must be an array of the collections `collection()` declares");
+  }
+  if (config.connectors.some((c) => c[VENDOR].id === DATA_VENDOR)) {
+    throw new Error(
+      `A connector in \`connectors\` is of the vendor "${DATA_VENDOR}", which the collections' operations are of; name it otherwise`,
+    );
+  }
+  const collections = new Map<string, Collection>();
+  for (const c of list) {
+    if (!isCollection(c)) throw new Error("`collections` holds something `collection()` did not make");
+    const other = collections.get(c.name);
+    if (other && other !== c) throw new Error(`Two collections are named "${c.name}"; name each once`);
+    collections.set(c.name, c);
+  }
+  return collections;
+}
+
+/** The config's connectors and the runtime's people types' (`peopleConnector`): what its data files are read against. */
+export const connectorsOf = (config: Pick<SanomaConfig, "connectors">): Connector<any, any>[] => [
+  ...config.connectors,
+  peopleConnector,
+];
+
 /**
  * What the connectors' setups attach under `key` (`withSetup`), by vendor id in `connectors`
  * order. One vendor's connectors may name one maker, as copies of one connector do, never two.
@@ -280,26 +380,36 @@ function scenariosAt(root: string | undefined): URL | undefined {
 }
 
 /**
- * The data files under `root`, as a drift run records them: each resource without its write-only
- * values, which a run never compares and never records, and the problems.
+ * The data files under `root` and the lockfile beside them, in one read, as a drift or apply run
+ * records them: each resource with its binding, without its write-only values (a secret marker
+ * names one, and stays), which a run never compares and never records, the bindings, the orphans
+ * and the problems.
  */
 async function readDeclared(
   root: string | undefined,
   connectors: readonly Connector<any, any>[],
+  declarable: ReadonlyMap<string, Resource>,
   types: ReadonlyMap<string, Resource>,
-): Promise<DriftDeclared> {
-  // Loaded when a drift run reads the files, not with the worker: the reader parses with oxc-parser.
+): Promise<Omit<ApplyDeclared, "rebinds">> {
+  // Loaded when a run reads the files, not with the worker: the reader parses with oxc-parser.
   const { readDataFiles } = await import("./resources.ts");
-  const { resources, problems } = readDataFiles(root, connectors, types);
+  const { resources, bindings, orphans, problems } = readDataFiles(root, connectors, declarable);
   return {
-    resources: resources.map(({ id, vendor, type, name, desired, refs }) => ({
-      id,
-      vendor,
-      type,
-      name,
-      desired: withoutWriteOnly(types.get(`${vendor}.${type}`)!.fields, desired),
-      refs,
-    })),
+    // Only `types`' resources have a vendor object to check or apply: not the people's (vendorless).
+    resources: resources
+      .filter((r) => types.has(`${r.vendor}.${r.type}`))
+      .map(({ id, vendor, type, name, identity, binding, desired, refs }) => ({
+        id,
+        vendor,
+        type,
+        name,
+        ...(identity !== undefined && { identity }),
+        ...(binding !== undefined && { binding }),
+        desired: withoutWriteOnly(types.get(`${vendor}.${type}`)!.fields, desired),
+        refs,
+      })),
+    bindings,
+    orphans,
     problems,
   };
 }
@@ -362,13 +472,23 @@ function guarded(vendor: string, env: DriverEnv, fn: DriverFn): DriverFn {
  * Every operation a workflow uses must be one the config's connectors declare, with a driver.
  * The workflow normally imports the same connector object; a copy is accepted only if it
  * declares the same effect and retry setting, and the worker's declaration is used either way.
+ * None may change a declared resource (`isChangeOp`): only the built-in apply workflow does.
  */
-function checkUses(wf: WorkflowDefinition<any, any>, ops: Map<string, Op>, impls: Map<string, unknown>) {
+function checkUses(
+  wf: WorkflowDefinition<any, any>,
+  ops: Map<string, Op>,
+  impls: Map<string, unknown>,
+  types: ReadonlyMap<string, Resource>,
+) {
   const problems: string[] = [];
   for (const op of (wf.uses as readonly Use[]).filter(isOp)) {
     const known = ops.get(op.id);
     if (!known) problems.push(`${op.id} is not declared by any connector in \`connectors\``);
-    else if (known !== op && (known.effect !== op.effect || known.idempotent !== op.idempotent)) {
+    else if (isChangeOp(known, types)) {
+      problems.push(
+        `${op.id} changes a declared resource, which only ${APPLY_WORKFLOW} does: change the data file instead`,
+      );
+    } else if (known !== op && (known.effect !== op.effect || known.idempotent !== op.idempotent)) {
       problems.push(
         `${op.id} is declared with effect "${op.effect}"${op.idempotent ? " (idempotent)" : ""}, ` +
           `but its connector says "${known.effect}"${known.idempotent ? " (idempotent)" : ""}`,

package/src/constructors.ts

@@ -0,0 +1,4 @@
+// `@sanoma-ai/workflows/resources`: what a data file imports from the runtime: `secret`, which
+// names a stored secret, and `sanoma`, the constructors of its people types (`sanoma.person`, …).
+export { secret, type Secret } from "./secret.ts";
+export { sanoma } from "./person.ts";

package/src/credentials.ts

@@ -1,20 +1,73 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 import { Client } from "pg";
 import { credentialsOf } from "./env.ts";
 import { CREDENTIALS_TABLE as TABLE, type Db, prepareDatabase } from "./db.ts";
 import { info, warn } from "./log.ts";
 import type { Driver } from "./op.ts";
+import type { Secrets } from "./secret.ts";
 import { errorMessage } from "./shared.ts";
 
 // Where the credentials set from the app live: one table in the config's database, beside DBOS's
 // own (made by `prepareDatabase` in db.ts). A value is read here only, by the worker to load it
-// into its environment and by the client to check it, and leaves neither. The write
-// (`storeCredential`) and the read (`storedCredentials`) are the only places that touch `value`,
-// so a hosted deployment's encryption goes there.
+// into its environment or hand it to a driver (`storedSecrets`) and by the client to check it,
+// and leaves none of them. The write (`storeCredential`, `ensureCredential`) and the read
+// (`storedCredentials`) are the only places that touch `value`, which holds it encrypted
+// (`encrypt`) under `SANOMA_SECRETS_KEY`.
 
 /** Where a change is announced, with the variable's name as the payload. */
 const CHANNEL = "sanoma_credentials";
 
+/** The variable holding the key the stored values are encrypted with: 32 bytes, base64. */
+export const SECRETS_KEY = "SANOMA_SECRETS_KEY";
+
+/** What starts an encrypted value; a value without it is a plaintext one stored before encryption, read as it is. */
+const V1 = "v1:";
+const CIPHER = "aes-256-gcm";
+const TAG_BYTES = 16;
+
+/** The key from the environment, or an error naming the variable. */
+function secretsKey(): Buffer {
+  const text = process.env[SECRETS_KEY];
+  if (!text) {
+    throw new Error(
+      `${SECRETS_KEY} is not set: it encrypts the stored credentials; set it to 32 random bytes, base64 (\`openssl rand -base64 32\`)`,
+    );
+  }
+  const key = Buffer.from(text, "base64");
+  if (key.length !== 32) throw new Error(`${SECRETS_KEY} must be 32 bytes, base64; it is ${key.length} bytes`);
+  return key;
+}
+
+/**
+ * `name`'s value encrypted for the table: `v1:<iv, base64>:<ciphertext and tag, base64>`,
+ * AES-256-GCM, with the name as associated data, so a value moved to another row does not decrypt.
+ */
+export function encrypt(name: string, value: string): string {
+  const iv = randomBytes(12);
+  const cipher = createCipheriv(CIPHER, secretsKey(), iv).setAAD(Buffer.from(name));
+  const sealed = Buffer.concat([cipher.update(value, "utf8"), cipher.final(), cipher.getAuthTag()]);
+  return `${V1}${iv.toString("base64")}:${sealed.toString("base64")}`;
+}
+
+/** The value `name`'s row holds: decrypted, or a plaintext one as it is (it is encrypted on its next write). */
+export function decrypt(name: string, stored: string): string {
+  if (!stored.startsWith(V1)) return stored;
+  const key = secretsKey();
+  const [iv = "", body = ""] = stored.slice(V1.length).split(":");
+  const sealed = Buffer.from(body, "base64");
+  try {
+    const decipher = createDecipheriv(CIPHER, key, Buffer.from(iv, "base64")).setAAD(Buffer.from(name));
+    decipher.setAuthTag(sealed.subarray(-TAG_BYTES));
+    return Buffer.concat([decipher.update(sealed.subarray(0, -TAG_BYTES)), decipher.final()]).toString("utf8");
+  } catch (err) {
+    throw new Error(
+      `the stored ${name} cannot be decrypted: ${SECRETS_KEY} is not the key it was stored with, or the row was not stored as ${name}`,
+      { cause: err },
+    );
+  }
+}
+
 /** The stored rows of these names, values included: for loading into an environment or checking, never for showing. */
 export async function storedCredentials(
   db: Db,
@@ -24,7 +77,9 @@ export async function storedCredentials(
     `SELECT name, value, set_by, set_at FROM ${TABLE} WHERE name = ANY($1)`,
     [names],
   );
-  return new Map(rows.map((r) => [r.name, { value: r.value, setBy: r.set_by, setAt: r.set_at.toISOString() }]));
+  return new Map(
+    rows.map((r) => [r.name, { value: decrypt(r.name, r.value), setBy: r.set_by, setAt: r.set_at.toISOString() }]),
+  );
 }
 
 /** Upserts the value and announces it, in one statement, so a worker never hears of a change it cannot read. */
@@ -36,10 +91,40 @@ export async function storeCredential(
     `WITH stored AS (INSERT INTO ${TABLE} (name, value, set_by) VALUES ($1, $2, $3) ` +
       "ON CONFLICT (name) DO UPDATE SET value = EXCLUDED.value, set_by = EXCLUDED.set_by, set_at = now() " +
       `RETURNING name) SELECT pg_notify('${CHANNEL}', name) FROM stored`,
-    [name, value, setBy],
+    [name, encrypt(name, value), setBy],
   );
 }
 
+/**
+ * The stored value of `name`; when there is none, `make()`'s, stored first and announced. Of two
+ * at once, the first stored wins, and both return it.
+ */
+export async function ensureCredential(
+  db: Db,
+  { name, make, setBy }: { name: string; make: () => string; setBy: string },
+): Promise<string> {
+  const stored = (await storedCredentials(db, [name])).get(name);
+  if (stored) return stored.value;
+  await db.query(
+    `WITH stored AS (INSERT INTO ${TABLE} (name, value, set_by) VALUES ($1, $2, $3) ON CONFLICT (name) DO NOTHING ` +
+      `RETURNING name) SELECT pg_notify('${CHANNEL}', name) FROM stored`,
+    [name, encrypt(name, make()), setBy],
+  );
+  return (await storedCredentials(db, [name])).get(name)!.value;
+}
+
+/**
+ * The secrets store a live driver is given (`CallContext.secrets`): a variable the environment
+ * sets wins, as it does for a driver's `env`; else the stored value. `ensure` stores what it
+ * makes as `setBy`.
+ */
+export function storedSecrets(db: () => Promise<Db>, setBy: string): Secrets {
+  return {
+    get: async (name) => process.env[name] || (await storedCredentials(await db(), [name])).get(name)?.value,
+    ensure: async (name, make) => process.env[name] || ensureCredential(await db(), { name, make, setBy }),
+  };
+}
+
 /** Deletes the row, announcing it when there was one. */
 export async function deleteCredential(db: Db, name: string): Promise<void> {
   await db.query(

package/src/data.ts

@@ -0,0 +1,10 @@
+// `@sanoma-ai/workflows/data`: what a company's `resources/data.ts` declares its collections with.
+export {
+  collection,
+  type Collection,
+  type Field,
+  type FieldType,
+  type RecordOf,
+  type RequiredTextKeys,
+} from "./collection.ts";
+export type { ListQuery, Saved } from "./shared.ts";