@shivaedev/work-fleet 0.1.0 → 0.2.0

package/src/storage/makeForeignReservations.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
+import { fleetRecords } from "#fleetRecords.ts";
+import { makeFleetTransaction } from "#storage/makeFleetTransaction.ts";
+import { ForeignReservationRow } from "#storage/model.ts";
+
+export const makeForeignReservations = Effect.fn("FleetStore.makeForeignReservations")(function* (namespace: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const commit = yield* makeFleetTransaction;
+	const reservations = yield* makeRepository(ForeignReservationRow, {
+		idColumn: "owner",
+		spanPrefix: "FleetForeign",
+		tableName: `${namespace}_foreign_reservations`,
+	});
+	const lock = sql`select pg_advisory_xact_lock(hashtextextended(${`work_fleet_admission:${namespace}`}, 0))`;
+	return {
+		foreignReservations: () => reservations.findMany({ orderBy: { direction: "asc", field: "owner" } }),
+		releaseForeign: (owner: string) =>
+			commit(
+				[fleetRecords.list],
+				Effect.gen(function* () {
+					yield* lock;
+					yield* reservations.delete(owner);
+				}),
+			),
+		reserveForeign: (owner: string, occupancy: { readonly executing: boolean; readonly backlog: boolean } = { backlog: true, executing: true }) =>
+			commit(
+				[fleetRecords.list],
+				Effect.gen(function* () {
+					yield* lock;
+					const existing = yield* reservations.findMany({ where: { owner } });
+					if (existing.length === 0) {
+						yield* reservations.insertVoid({ owner, ...occupancy });
+					} else {
+						yield* reservations.updateVoid({ owner, ...occupancy });
+					}
+				}),
+			),
+	};
+});

package/src/storage/makePostgresFleetStore.ts

@@ -1,16 +1,20 @@
 import { Effect, Array as EffectArray, Schema } from "effect";
 import { SqlClient } from "effect/sql";
-import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
+import { makeRepository, OptimisticConcurrencyError } from "@shivaedev/effect-sql/repository.ts";
 import { fleetRecords } from "#fleetRecords.ts";
 import { checkRecordAdmission } from "#storage/admission.ts";
 import { admissionReads } from "#storage/admissionReads.ts";
 import { StorageConflict } from "#storage/errors.ts";
 import type { FleetStoreOptions } from "#storage/FleetStoreOptions.ts";
 import { makeFleetTransaction } from "#storage/makeFleetTransaction.ts";
+import { makeForeignReservations } from "#storage/makeForeignReservations.ts";
 import { migrateFleet } from "#storage/migrateFleet.ts";
-import { type AdmissionLimits, ForeignReservationRow, recordColumns, recordInput, recordModel, type Versioned } from "#storage/model.ts";
+import { type AdmissionLimits, recordModel, type Versioned } from "#storage/model.ts";
 import { nextAdmissionOrder } from "#storage/nextAdmissionOrder.ts";
 import { operationEntries } from "#storage/operationEntries.ts";
+import { readRecords } from "#storage/readRecords.ts";
+import { inputColumns, makeRecordChildren } from "#storage/recordChildren.ts";
+import { recordShape } from "#storage/recordShape.ts";
 import { withRecordTimes } from "#storage/recordTimes.ts";
 import { recordValue, recordValues } from "#storage/recordValue.ts";
 
@@ -25,36 +29,40 @@ export const makePostgresFleetStore = Effect.fn("FleetStore.makePostgresFleetSto
 	const namespace = options.namespace ?? "work_fleet";
 	const commit = yield* makeFleetTransaction;
 	const records = `${namespace}_records`;
-	const foreign = `${namespace}_foreign_reservations`;
-	const columns = recordColumns(schema);
+	const shape = recordShape(schema);
 	const model = recordModel(schema);
+	const saveChildren = yield* makeRecordChildren(namespace, shape);
 	const rows = yield* makeRepository(model, { idColumn: "work_id", spanPrefix: "FleetRow", tableName: records, versionColumn: "version" });
-	const reservations = yield* makeRepository(ForeignReservationRow, { idColumn: "owner", spanPrefix: "FleetForeign", tableName: foreign });
+	const foreign = yield* makeForeignReservations(namespace);
 	const encodeRecord = Schema.encodeEffect(schema);
 	const decodeObject = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const decodeInsert = Schema.decodeUnknownEffect(model.insert);
 	const decodeRecord = Schema.decodeUnknownEffect(schema);
 	const decodeRecords = Schema.decodeUnknownEffect(Schema.Array(schema));
 	function decode(row: { readonly "work_id": string; readonly version: number }) {
-		return recordValue(row, columns).pipe(
+		return recordValue(row, shape, namespace).pipe(
 			Effect.flatMap(decodeRecord),
+			Effect.provideService(SqlClient.SqlClient, sql),
 			Effect.map((value) => ({ value, version: row.version + 1 })),
 		);
 	}
-	const loadEntry = Effect.fn("FleetStore.loadEntry")(function* (workId: string) {
+	const readEntry = Effect.fn("FleetStore.readEntry")(function* (workId: string) {
 		const found = yield* rows.findById(workId).pipe(Effect.catchTag("NoSuchElementError", () => Effect.succeed(undefined)));
 		return found === undefined ? undefined : { order: found.admission_order, stored: yield* decode(found) };
 	});
+	function loadEntry(workId: string) {
+		return readRecords(namespace, readEntry(workId)).pipe(Effect.provideService(SqlClient.SqlClient, sql));
+	}
 	function load(workId: string) {
 		return loadEntry(workId).pipe(Effect.map((entry) => entry?.stored));
 	}
-	const list = Effect.fn("FleetStore.list")(function* () {
+	const readList = Effect.fn("FleetStore.readList")(function* () {
 		const found = yield* rows.findMany({ orderBy: { direction: "asc", field: "admission_order" } });
-		const values = yield* decodeRecords(yield* recordValues(found, columns));
+		const values = yield* decodeRecords(yield* recordValues(found, shape, namespace).pipe(Effect.provideService(SqlClient.SqlClient, sql)));
 		return EffectArray.zipWith(values, found, (value, row) => ({ value, version: row.version + 1 }));
 	});
-	function foreignReservations() {
-		return reservations.findMany({ orderBy: { direction: "asc", field: "owner" } });
+	function list() {
+		return readRecords(namespace, readList()).pipe(Effect.provideService(SqlClient.SqlClient, sql));
 	}
 	const lock = sql`select pg_advisory_xact_lock(hashtextextended(${`work_fleet_admission:${namespace}`}, 0))`.pipe(Effect.asVoid);
 	const persist = Effect.fn("FleetStore.persist")(function* (
@@ -65,13 +73,14 @@ export const makePostgresFleetStore = Effect.fn("FleetStore.makePostgresFleetSto
 		entry: { readonly order: bigint; readonly stored: Versioned<TSchema["Type"]> } | undefined,
 	) {
 		const requeue = entry !== undefined && options.requeue?.(record, entry.stored.value) === true;
-		const input = yield* decodeInsert({ ...recordInput(encoded, columns), "work_id": workId });
+		const input = yield* decodeInsert({ ...inputColumns(encoded, shape), "work_id": workId });
 		if (entry === undefined) {
 			yield* rows.insertVoid(input);
 		} else {
 			const order = requeue ? yield* nextAdmissionOrder(sql, records) : entry.order;
 			yield* rows.updateVoid({ ...input, "admission_order": order, version: expectedVersion === null ? 0 : expectedVersion - 1 });
 		}
+		yield* saveChildren(workId, encoded, entry !== undefined);
 		return { value: record, version: (expectedVersion ?? 0) + 1 };
 	});
 	const write = Effect.fn("FleetStore.write")(function* (
@@ -96,52 +105,30 @@ export const makePostgresFleetStore = Effect.fn("FleetStore.makePostgresFleetSto
 				}
 				const reads = admissionReads(options, record, previous?.value, limits);
 				const entries = reads.records ? yield* list() : [];
-				const external = reads.foreign ? yield* foreignReservations() : [];
+				const external = reads.foreign ? yield* foreign.foreignReservations() : [];
 				yield* checkRecordAdmission(options, record, previous?.value, entries, external, limits);
 				const timed = yield* withRecordTimes(schema, encoded, previous?.value);
 				return yield* persist(workId, expectedVersion, timed.value, timed.encoded, entry);
 			}),
 		).pipe(
-			Effect.catchTag("OptimisticConcurrencyError", () =>
-				Effect.flatMap(load(workId), (actual) =>
-					Effect.fail(new StorageConflict({ actualVersion: actual?.version ?? null, expectedVersion, workId })),
-				),
+			Effect.catchIf(
+				(error) => error instanceof OptimisticConcurrencyError,
+				() =>
+					Effect.flatMap(load(workId), (actual) =>
+						Effect.fail(new StorageConflict({ actualVersion: actual?.version ?? null, expectedVersion, workId })),
+					),
 			),
 		);
 	});
 	return {
 		compareAndSet: (workId: string, expectedVersion: number, record: TSchema["Type"], limits?: AdmissionLimits) =>
 			write(workId, expectedVersion, record, limits),
-		foreignReservations,
+		...foreign,
 		hasLaunchRetry: () => rows.findMany({ select: ["launchRetry"] }).pipe(Effect.map((entries) => entries.some((row) => row.launchRetry !== null))),
 		initialize: () => commit([fleetRecords.list], migrateFleet(namespace)),
 		insert: (record: TSchema["Type"], limits?: AdmissionLimits) => write(record.workId, null, record, limits),
 		list,
 		load,
-		operationEntries: (operationId: string) =>
-			rows
-				.findMany({ select: ["work_id", "version", "attempts", "history"] })
-				.pipe(Effect.flatMap((entries) => operationEntries(entries, operationId))),
-		releaseForeign: (owner: string) =>
-			commit(
-				[fleetRecords.list],
-				Effect.gen(function* () {
-					yield* lock;
-					yield* reservations.delete(owner);
-				}),
-			),
-		reserveForeign: (owner: string, occupancy: { readonly executing: boolean; readonly backlog: boolean } = { backlog: true, executing: true }) =>
-			commit(
-				[fleetRecords.list],
-				Effect.gen(function* () {
-					yield* lock;
-					const existing = yield* reservations.findMany({ where: { owner } });
-					if (existing.length === 0) {
-						yield* reservations.insertVoid({ owner, ...occupancy });
-					} else {
-						yield* reservations.updateVoid({ owner, ...occupancy });
-					}
-				}),
-			),
+		operationEntries: (operationId: string) => operationEntries(namespace, operationId).pipe(Effect.provideService(SqlClient.SqlClient, sql)),
 	};
 });

package/src/storage/model.ts

@@ -1,6 +1,8 @@
-import { Effect, Schema, SchemaAST } from "effect";
+import { Effect, Schema } from "effect";
 import { Model } from "effect/schema";
 import { FleetRecord } from "#model.ts";
+import { inputColumns } from "#storage/recordChildren.ts";
+import { type ColumnKind, columnSchema, recordShape, shapeColumns } from "#storage/recordShape.ts";
 import { recordValue } from "#storage/recordValue.ts";
 export interface Versioned<A> {
 	readonly value: A;
@@ -14,63 +16,20 @@ export interface AdmissionLimits {
 	readonly scheduling?: { readonly now: number; readonly areaMergeWaitMs: number };
 }
 
-function scalarKind(ast: SchemaAST.AST): "string" | "number" | "boolean" | "json" {
-	if (SchemaAST.isString(ast)) {
-		return "string";
-	}
-	if (SchemaAST.isNumber(ast)) {
-		return "number";
-	}
-	if (SchemaAST.isBoolean(ast)) {
-		return "boolean";
-	}
-	if (SchemaAST.isLiteral(ast)) {
-		if (typeof ast.literal === "string") {
-			return "string";
-		}
-		if (typeof ast.literal === "number") {
-			return "number";
-		}
-		if (typeof ast.literal === "boolean") {
-			return "boolean";
-		}
-	}
-	if (SchemaAST.isUnion(ast)) {
-		const kinds = new Set(ast.types.filter((type) => !SchemaAST.isUndefined(type)).map(scalarKind));
-		if (kinds.size === 1) {
-			return [...kinds][0] ?? "json";
-		}
-	}
-	return "json";
-}
-
 export function recordColumns(schema: Schema.Top = FleetRecord) {
-	const ast = SchemaAST.toEncoded(schema.ast);
-	const base = SchemaAST.toEncoded(FleetRecord.ast);
-	const properties = [...(SchemaAST.isObjects(base) ? base.propertySignatures : []), ...(SchemaAST.isObjects(ast) ? ast.propertySignatures : [])];
-	return Object.fromEntries(properties.filter((field) => field.name !== "workId").map((field) => [String(field.name), scalarKind(field.type)]));
-}
-
-function columnSchema(kind: string) {
-	if (kind === "number") {
-		return Schema.Number;
-	}
-	if (kind === "boolean") {
-		return Schema.Boolean;
-	}
-	return Schema.String;
+	return shapeColumns(recordShape(schema));
 }
 
 const rowFields = {
 	"admission_order": Model.Field({ select: Schema.BigInt, update: Schema.BigInt }),
-	attempts: Schema.NullOr(Schema.String),
+	attempts: Schema.NullOr(Schema.Boolean),
 	attentionOwner: Schema.NullOr(Schema.String),
 	blocker: Schema.NullOr(Schema.String),
-	checks: Schema.NullOr(Schema.String),
-	decision: Schema.NullOr(Schema.String),
-	history: Schema.NullOr(Schema.String),
-	launchRetry: Schema.NullOr(Schema.String),
-	outcome: Schema.NullOr(Schema.String),
+	checks: Schema.NullOr(Schema.Boolean),
+	decision: Schema.NullOr(Schema.Boolean),
+	history: Schema.NullOr(Schema.Boolean),
+	launchRetry: Schema.NullOr(Schema.Boolean),
+	outcome: Schema.NullOr(Schema.Boolean),
 	stage: Schema.NullOr(Schema.String),
 	version: Model.Field({ select: Schema.Number, update: Schema.Number }),
 	"work_id": Schema.String,
@@ -78,7 +37,11 @@ const rowFields = {
 class FleetRow extends Model.Class<FleetRow>("FleetRow")(rowFields) {}
 
 export function recordModel(schema: Schema.Top = FleetRecord): typeof FleetRow {
-	const fields = Object.fromEntries(Object.entries(recordColumns(schema)).map(([name, kind]) => [name, Schema.NullOr(columnSchema(kind))]));
+	return modelFromColumns(recordColumns(schema));
+}
+
+export function modelFromColumns(columns: Readonly<Record<string, ColumnKind>>): typeof FleetRow {
+	const fields = Object.fromEntries(Object.entries(columns).map(([name, kind]) => [name, columnSchema(kind)]));
 	// Explicit summary fields retain typed projections while the remaining fields come from the record schema.
 	class RecordRow extends Model.Class<RecordRow>("FleetRow")({ ...rowFields, ...fields }) {}
 	return RecordRow;
@@ -93,23 +56,10 @@ export type ForeignReservation = typeof ForeignReservation.Type;
 
 export class ForeignReservationRow extends Model.Class<ForeignReservationRow>("ForeignReservationRow")(ForeignReservation.fields) {}
 
-export function recordInput(value: string | object, columns: ReturnType<typeof recordColumns>) {
-	const encoded: Record<string, unknown> = typeof value === "string" ? JSON.parse(value) : { ...value };
-	return Object.fromEntries(
-		Object.entries(columns).map(([name, kind]) => {
-			if (encoded[name] === undefined) {
-				return [name, null];
-			}
-			return [name, kind === "json" ? JSON.stringify(encoded[name]) : encoded[name]];
-		}),
-	);
-}
-
-export function recordJson(row: object, columns: ReturnType<typeof recordColumns>) {
-	return recordValue(row, columns).pipe(Effect.map(JSON.stringify));
+export function recordInput(value: object, schema: Schema.Top = FleetRecord) {
+	return inputColumns(value, recordShape(schema));
 }
 
-export interface StoredRow {
-	readonly value: string;
-	readonly version: number;
+export function recordJson(row: object, namespace: string) {
+	return recordValue(row, recordShape(), namespace).pipe(Effect.map(JSON.stringify));
 }

package/src/storage/operationEntries.ts

@@ -1,24 +1,14 @@
-import { Effect, Schema } from "effect";
-import { Attempt, FleetRecord } from "#model.ts";
-import { recordValues } from "#storage/recordValue.ts";
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { childTable } from "#storage/recordChildren.ts";
 
-const OperationAttempts = Schema.Array(Schema.Struct({ operationId: Attempt.fields.operationId }));
-const decode = Schema.decodeUnknownEffect(
-	Schema.Array(
-		Schema.Struct({
-			attempts: OperationAttempts,
-			history: Schema.optional(Schema.Array(Schema.Struct({ attempts: OperationAttempts }))),
-			version: Schema.Number,
-			workId: FleetRecord.fields.workId,
-		}),
-	),
-);
-
-export const operationEntries = Effect.fn("FleetRow.operationEntries")(function* (rows: readonly object[], operationId: string) {
-	const records = yield* decode(yield* recordValues(rows, { attempts: "json", history: "json", version: "number" }));
-	return records.flatMap((record) =>
-		[...(record.history ?? []).flatMap((cycle) => cycle.attempts), ...record.attempts]
-			.filter((attempt) => attempt.operationId === operationId)
-			.map(() => ({ version: record.version + 1, workId: record.workId })),
-	);
+export const operationEntries = Effect.fn("FleetRow.operationEntries")(function* (namespace: string, operationId: string) {
+	const sql = yield* SqlClient.SqlClient;
+	return yield* sql<{ readonly workId: string; readonly version: number }>`
+		select records.work_id as "workId", records.version + 1 as version
+		from ${sql(`${namespace}_records`)} records join (
+			select work_id from ${sql(childTable(namespace, ["attempts"]))} where ${sql("operationId")} = ${operationId}
+			union all
+			select work_id from ${sql(childTable(namespace, ["history", "attempts"]))} where ${sql("operationId")} = ${operationId}
+		) attempts on attempts.work_id = records.work_id`;
 });

package/src/storage/preparationV12.ts

@@ -0,0 +1,31 @@
+import type { Shape } from "#storage/recordShape.ts";
+
+export const preparationV12 = {
+	fields: {
+		baselinePaths: { array: "string" },
+		baseRevision: "string",
+		configuration: {
+			array: {
+				fields: {
+					path: "string",
+					relevantKeys: { array: "string" },
+				},
+			},
+		},
+		contextComplete: "boolean",
+		dependencyPaths: { array: "string" },
+		observedAt: "number",
+		ownedPaths: { array: "string" },
+		qualityPaths: { array: "string" },
+		setupPaths: { array: "string" },
+		sourcePaths: { array: "string" },
+		validation: {
+			array: {
+				fields: {
+					command: "string",
+					revision: "string",
+				},
+			},
+		},
+	},
+} as const satisfies Shape;

package/src/storage/readRecords.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+
+export const readRecords = Effect.fn("FleetRow.readRecords")(function* <A, E, R>(namespace: string, body: Effect.Effect<A, E, R>) {
+	const sql = yield* SqlClient.SqlClient;
+	return yield* sql.withTransaction(
+		Effect.gen(function* () {
+			yield* sql`select pg_advisory_xact_lock_shared(hashtextextended(${`work_fleet_admission:${namespace}`}, 0))`;
+			return yield* body;
+		}),
+	);
+});

package/src/storage/recordChildren.ts

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { Model } from "effect/schema";
+import { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
+import { type Collection, collections, columnSchema, type Shape, shapeColumns } from "#storage/recordShape.ts";
+
+export function childTable(namespace: string, path: readonly string[]) {
+	return `${namespace}_c_${createHash("sha256").update(path.join(".")).digest("hex").slice(0, 12)}`;
+}
+
+export function positions(collection: Collection) {
+	return Array.from({ length: collection.parents.length + 1 }, (_unused, index) => `position${index}`);
+}
+
+function childModel(collection: Collection) {
+	class Child extends Model.Class<Child>("FleetChild")({
+		...Object.fromEntries(Object.entries(shapeColumns(collection.shape)).map(([name, kind]) => [name, columnSchema(kind)])),
+		...Object.fromEntries(positions(collection).map((name) => [name, Schema.Number])),
+		"work_id": Schema.String,
+	}) {}
+	return Child;
+}
+
+const decodeObject = Schema.decodeUnknownSync(Schema.Record(Schema.String, Schema.Unknown));
+
+export function objectValue(value: unknown): Record<string, unknown> {
+	return decodeObject(value);
+}
+
+function presence(value: unknown) {
+	return value === undefined ? null : true;
+}
+
+export function inputColumns(value: unknown, shape: Shape, path: readonly string[] = []): Record<string, unknown> {
+	const name = path.join("__");
+	if (typeof shape === "string") {
+		return { [name]: value ?? null };
+	}
+	if ("array" in shape) {
+		const stored = typeof shape.array === "string" ? (value ?? null) : presence(value);
+		return { [name]: stored };
+	}
+	const fields = value === undefined ? {} : objectValue(value);
+	return Object.assign(
+		path.length === 0 ? {} : { [name]: presence(value) },
+		...Object.entries(shape.fields).map(([key, field]) => inputColumns(fields[key], field, [...path, key])),
+	);
+}
+
+export const makeRecordChildren = Effect.fn("FleetRow.makeRecordChildren")(function* (namespace: string, shape: Shape) {
+	const sql = yield* SqlClient.SqlClient;
+	const tables = collections(shape);
+	const repositories = new Map(
+		yield* Effect.forEach(tables, (collection) =>
+			Effect.gen(function* () {
+				const model = childModel(collection);
+				const repository = yield* makeRepository(model, {
+					idColumn: "work_id",
+					spanPrefix: "FleetChild",
+					tableName: childTable(namespace, collection.path),
+				});
+				return [collection.path.join("."), { model, repository }] as const;
+			}),
+		),
+	);
+	const save = Effect.fn("FleetRow.save")(function* (workId: string, value: unknown, replace = true) {
+		if (replace) {
+			for (const collection of [...tables].reverse()) {
+				yield* sql`delete from ${sql(childTable(namespace, collection.path))} where work_id = ${workId}`;
+			}
+		}
+		function write(
+			current: unknown,
+			node: Shape,
+			path: readonly string[],
+			indices: readonly number[],
+		): Effect.Effect<void, Schema.SchemaError | SqlError> {
+			return Effect.gen(function* () {
+				if (current === undefined || typeof node === "string") {
+					return;
+				}
+				if ("fields" in node) {
+					const fields = objectValue(current);
+					yield* Effect.forEach(Object.entries(node.fields), ([name, field]) => write(fields[name], field, [...path, name], indices), {
+						discard: true,
+					});
+					return;
+				}
+				if (typeof node.array === "string") {
+					return;
+				}
+				yield* writeArray(current, node.array, path, indices);
+			});
+		}
+		function writeArray(
+			current: unknown,
+			item: Shape,
+			path: readonly string[],
+			indices: readonly number[],
+		): Effect.Effect<void, Schema.SchemaError | SqlError> {
+			return Effect.gen(function* () {
+				const child = repositories.get(path.join("."));
+				if (child === undefined) {
+					return yield* Effect.die("Missing Fleet collection");
+				}
+				const { model, repository } = child;
+				const entries = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Unknown))(current);
+				for (const [index, entry] of entries.entries()) {
+					const keys = [...indices, index];
+					const input = yield* Schema.decodeUnknownEffect(model.insert)({
+						...inputColumns(entry, item),
+						...Object.fromEntries(keys.map((position, depth) => [`position${depth}`, position])),
+						"work_id": workId,
+					});
+					yield* repository.insertVoid(input);
+					yield* write(entry, item, path, keys);
+				}
+			});
+		}
+
+		yield* write(value, shape, [], []);
+	});
+	return save;
+});
+
+export const writeChildren = Effect.fn("FleetRow.writeChildren")(function* (namespace: string, workId: string, value: unknown, shape: Shape) {
+	const save = yield* makeRecordChildren(namespace, shape);
+	yield* save(workId, value);
+});

package/src/storage/recordShape.ts

@@ -0,0 +1,137 @@
+import * as PgTypes from "@effect/sql-pg/PgTypes";
+import { Effect, Result, Schema, SchemaAST, SchemaGetter } from "effect";
+import { FleetRecord } from "#model.ts";
+
+export type ScalarKind = "string" | "number" | "boolean";
+export type Shape = ScalarKind | { readonly array: Shape } | { readonly fields: Readonly<Record<string, Shape>> };
+export type ColumnKind = ScalarKind | "string[]" | "number[]" | "boolean[]";
+
+function flatten(ast: SchemaAST.AST): readonly SchemaAST.AST[] {
+	return SchemaAST.isUnion(ast) ? ast.types.flatMap(flatten) : [ast];
+}
+
+function fromAsts(asts: readonly SchemaAST.AST[]): Shape {
+	const types = asts.flatMap(flatten).filter((ast) => !SchemaAST.isUndefined(ast));
+	if (types.every(SchemaAST.isObjects)) {
+		const names = [...new Set(types.flatMap((ast) => ast.propertySignatures.map((field) => String(field.name))))];
+		return {
+			fields: Object.fromEntries(
+				names.map((name) => [
+					name,
+					fromAsts(types.flatMap((ast) => ast.propertySignatures.filter((field) => field.name === name).map((field) => field.type))),
+				]),
+			),
+		};
+	}
+	if (types.every(SchemaAST.isArrays)) {
+		return { array: fromAsts(types.flatMap((ast) => ast.rest)) };
+	}
+	const kinds = types.map((ast) => {
+		if (SchemaAST.isString(ast)) {
+			return "string";
+		}
+		if (SchemaAST.isNumber(ast)) {
+			return "number";
+		}
+		if (SchemaAST.isBoolean(ast)) {
+			return "boolean";
+		}
+		if (SchemaAST.isLiteral(ast)) {
+			return typeof ast.literal;
+		}
+		throw new Error(`Unsupported Fleet storage schema: ${ast._tag}`);
+	});
+	const kind = kinds[0];
+	if ((kind === "string" || kind === "number" || kind === "boolean") && kinds.every((value) => value === kind)) {
+		return kind;
+	}
+	throw new Error("Fleet storage requires a single typed column kind");
+}
+
+export function schemaShape(schema: Schema.Top): Shape {
+	const shape = fromAsts([SchemaAST.toEncoded(schema.ast)]);
+	if (typeof shape === "object" && "fields" in shape) {
+		const { workId: _workId, ...fields } = shape.fields;
+		return { fields };
+	}
+	throw new Error("Fleet records must be objects");
+}
+
+export function recordShape(schema: Schema.Top = FleetRecord): Shape {
+	const base = schemaShape(FleetRecord);
+	const extra = schemaShape(schema);
+	if (typeof base === "object" && "fields" in base && typeof extra === "object" && "fields" in extra) {
+		return { fields: { ...base.fields, ...extra.fields } };
+	}
+	throw new Error("Fleet records must be objects");
+}
+
+export function shapeColumns(shape: Shape, prefix: readonly string[] = []): Record<string, ColumnKind> {
+	const name = prefix.join("__");
+	if (typeof shape === "string") {
+		return { [name]: shape };
+	}
+	if ("array" in shape) {
+		if (typeof shape.array !== "string") {
+			return { [name]: "boolean" };
+		}
+		const kinds = { boolean: "boolean[]", number: "number[]", string: "string[]" } as const;
+		return { [name]: kinds[shape.array] };
+	}
+	return Object.assign(
+		prefix.length === 0 ? {} : { [name]: "boolean" },
+		...Object.entries(shape.fields).map(([key, field]) => shapeColumns(field, [...prefix, key])),
+	);
+}
+
+export interface Collection {
+	readonly parents: readonly string[];
+	readonly path: readonly string[];
+	readonly shape: Shape;
+}
+
+export function collections(shape: Shape, path: readonly string[] = [], parents: readonly string[] = []): Collection[] {
+	if (typeof shape === "string") {
+		return [];
+	}
+	if ("array" in shape) {
+		if (typeof shape.array === "string") {
+			return [];
+		}
+		return [{ parents, path, shape: shape.array }, ...collections(shape.array, path, [...parents, path.join(".")])];
+	}
+	return Object.entries(shape.fields).flatMap(([key, field]) => collections(field, [...path, key], parents));
+}
+
+export const sqlTypes: Readonly<Record<ColumnKind, string>> = {
+	boolean: "boolean",
+	"boolean[]": "boolean[]",
+	number: "double precision",
+	"number[]": "double precision[]",
+	string: "text",
+	"string[]": "text[]",
+};
+
+function scalarCodec(kind: ColumnKind) {
+	if (kind.startsWith("number")) {
+		return { oid: PgTypes.OID.float8, schema: Schema.Number };
+	}
+	if (kind.startsWith("boolean")) {
+		return { oid: PgTypes.OID.bool, schema: Schema.Boolean };
+	}
+	return { oid: PgTypes.OID.text, schema: Schema.String };
+}
+
+export function columnSchema(kind: ColumnKind): Schema.Top & { readonly DecodingServices: never; readonly EncodingServices: never } {
+	const { schema: Scalar, oid } = scalarCodec(kind);
+	if (!kind.endsWith("[]")) {
+		return Schema.NullOr(Scalar);
+	}
+	const ArrayValue = Schema.NullOr(Schema.Array(Scalar));
+	return Schema.Unknown.pipe(
+		Schema.decodeTo(ArrayValue, {
+			decode: SchemaGetter.transformEffect((value) => Schema.decodeUnknownEffect(ArrayValue)(value).pipe(Effect.mapError((error) => error.issue))),
+			encode: SchemaGetter.transform((values) => (values === null ? null : Result.getOrThrow(PgTypes.array(values, oid)))),
+		}),
+	);
+}