@shivaedev/work-fleet 0.1.1 → 0.2.0

package/src/storage/recordValue.ts

@@ -1,42 +1,55 @@
-import { Effect, Result, Schema } from "effect";
-import type { recordColumns } from "#storage/model.ts";
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { childTable, objectValue } from "#storage/recordChildren.ts";
+import { collections, type Shape } from "#storage/recordShape.ts";
 
-const decodeJson = Schema.decodeUnknownResult(Schema.fromJsonString(Schema.Unknown));
+type Row = Readonly<Record<string, unknown>>;
 
-function jsonValue(value: unknown) {
-	try {
-		return typeof value === "string" ? Result.succeed(JSON.parse(value)) : decodeJson(value);
-	} catch {
-		return decodeJson(value);
+export const recordValues = Effect.fn("FleetRow.recordValues")(function* (rows: readonly object[], shape: Shape, namespace: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const roots = rows.map(objectValue);
+	const children = new Map<string, readonly Row[]>();
+	if (roots.length === 0) {
+		return [];
 	}
-}
-
-export const recordValues = Effect.fn("FleetRow.recordValues")(function* (rows: readonly object[], columns: ReturnType<typeof recordColumns>) {
-	const entries = Object.entries(columns);
-	const records: Record<string, unknown>[] = [];
-	for (const row of rows) {
-		const values: Record<string, unknown> = { ...row };
-		const fields: Record<string, unknown> = { workId: values.work_id };
-		for (const [name, kind] of entries) {
-			const value = values[name];
-			if (value === null || value === undefined) {
-				continue;
-			}
-			if (kind !== "json") {
-				fields[name] = value;
-				continue;
-			}
-			const decoded = jsonValue(value);
-			if (decoded._tag === "Failure") {
-				return yield* Effect.fail(decoded.failure);
-			}
-			fields[name] = decoded.success;
+	for (const collection of collections(shape)) {
+		const parent = collection.parents.at(-1);
+		const sources = parent === undefined ? roots : (children.get(parent) ?? []);
+		const offset = parent === undefined ? 0 : parent.split(".").length;
+		const marker = collection.path.slice(offset).join("__");
+		const workIds = [...new Set(sources.filter((row) => row[marker] !== null && row[marker] !== undefined).map((row) => row.work_id))];
+		if (workIds.length === 0) {
+			continue;
+		}
+		const found =
+			yield* sql<Row>`select * from ${sql(childTable(namespace, collection.path))} where ${sql.in("work_id", workIds)} order by ${sql.csv(Array.from({ length: collection.parents.length + 1 }, (_unused, index) => sql`${sql(`position${index}`)}`))}`;
+		children.set(collection.path.join("."), found);
+	}
+	function read(node: Shape, row: Row, path: readonly string[], prefix: readonly string[], indices: readonly number[]): unknown {
+		const name = prefix.join("__");
+		if (typeof node === "string") {
+			return row[name] ?? undefined;
+		}
+		if (prefix.length > 0 && (row[name] === null || row[name] === undefined)) {
+			return undefined;
+		}
+		if ("fields" in node) {
+			return Object.fromEntries(
+				Object.entries(node.fields)
+					.map(([key, field]) => [key, read(field, row, [...path, key], [...prefix, key], indices)])
+					.filter(([_key, value]) => value !== undefined),
+			);
+		}
+		if (typeof node.array === "string") {
+			return row[name];
 		}
-		records.push(fields);
+		return (children.get(path.join(".")) ?? [])
+			.filter((child) => child.work_id === row.work_id && indices.every((position, index) => child[`position${index}`] === position))
+			.map((child) => read(node.array, child, path, [], [...indices, Number(child[`position${indices.length}`])]));
 	}
-	return records;
+	return roots.map((row) => ({ ...objectValue(read(shape, row, [], [], [])), workId: row.work_id }));
 });
 
-export function recordValue(row: object, columns: ReturnType<typeof recordColumns>) {
-	return recordValues([row], columns).pipe(Effect.map(([value]) => value));
+export function recordValue(row: object, shape: Shape, namespace: string) {
+	return recordValues([row], shape, namespace).pipe(Effect.map(([value]) => value));
 }

package/src/storage/shapeV12.ts

@@ -0,0 +1,11 @@
+import { attemptV12 } from "#storage/attemptV12.ts";
+import { cycleV12 } from "#storage/cycleV12.ts";
+import type { Shape } from "#storage/recordShape.ts";
+
+const cycle = { ...cycleV12.fields, attempts: { array: attemptV12 } };
+export const shapeV12 = {
+	fields: {
+		...cycle,
+		history: { array: { fields: { ...cycle, archivedAt: "number" } } },
+	},
+} as const satisfies Shape;

package/src/storage/textRecordValue.ts

@@ -0,0 +1,16 @@
+import { Effect, Schema } from "effect";
+import { legacyColumns } from "#storage/legacyColumns.ts";
+
+export const textRecordValue = Effect.fn("FleetStore.textRecordValue")(function* (
+	row: Readonly<Record<string, unknown>>,
+	structured: readonly string[],
+) {
+	const value: Record<string, unknown> = {};
+	for (const name of Object.keys(legacyColumns)) {
+		const field = row[structured.includes(name) ? `legacy_${name}` : name];
+		if (field !== null) {
+			value[name] = structured.includes(name) ? yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(field) : field;
+		}
+	}
+	return value;
+});

package/src/storage/typedDecisionsV12.ts

@@ -0,0 +1,100 @@
+import type { Shape } from "#storage/recordShape.ts";
+
+export const decisionV12 = {
+	fields: {
+		attentionOwner: "string",
+		boardAcknowledgementDisposition: "string",
+		code: "string",
+		id: "string",
+		links: { array: "string" },
+		publicationWork: {
+			fields: {
+				approved: "boolean",
+				areas: { array: "string" },
+				context: "string",
+				deliverable: "string",
+				dependsOn: { array: "string" },
+				revision: "string",
+				sourcePath: "string",
+				status: "string",
+				workId: "string",
+			},
+		},
+		published: {
+			fields: {
+				itemId: "string",
+				questionId: "string",
+				request: "string",
+				revision: "string",
+				sourcePath: "string",
+				workId: "string",
+				workRevision: "string",
+				workSourcePath: "string",
+			},
+		},
+		reason: "string",
+		recommendation: "string",
+		worker: {
+			fields: {
+				sessionId: "string",
+				turnId: "string",
+			},
+		},
+	},
+} as const satisfies Shape;
+
+export const responsesV12 = {
+	array: {
+		fields: {
+			action: "string",
+			boardAcknowledged: "boolean",
+			boardAcknowledgementDisposition: "string",
+			decisionId: "string",
+			processedAt: "number",
+			published: {
+				fields: {
+					itemId: "string",
+					questionId: "string",
+					request: "string",
+					revision: "string",
+					sourcePath: "string",
+					workId: "string",
+					workRevision: "string",
+					workSourcePath: "string",
+				},
+			},
+			questionId: "string",
+			questionRevision: "string",
+			responseId: "string",
+			type: "string",
+		},
+	},
+} as const satisfies Shape;
+
+export const supersededDecisionsV12 = {
+	array: {
+		fields: {
+			boardAcknowledged: "boolean",
+			boardAcknowledgementDisposition: "string",
+			published: {
+				fields: {
+					itemId: "string",
+					questionId: "string",
+					request: "string",
+					revision: "string",
+					sourcePath: "string",
+					workId: "string",
+					workRevision: "string",
+					workSourcePath: "string",
+				},
+			},
+			reassignedTo: {
+				fields: {
+					attentionOwner: "string",
+					decisionId: "string",
+				},
+			},
+			supersededAt: "number",
+		},
+	},
+} as const satisfies Shape;

package/src/storage/typedTables.ts

@@ -0,0 +1,39 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { createCollections } from "#storage/createCollections.ts";
+import { legacyColumns } from "#storage/legacyColumns.ts";
+import { modelFromColumns } from "#storage/model.ts";
+import { inputColumns, makeRecordChildren } from "#storage/recordChildren.ts";
+import { shapeColumns, sqlTypes } from "#storage/recordShape.ts";
+import { shapeV12 } from "#storage/shapeV12.ts";
+import { textRecordValue } from "#storage/textRecordValue.ts";
+
+export const typedTables = Effect.fn("FleetStore.typedTables")(function* (namespace: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const table = `${namespace}_records`;
+	const structured = Object.entries(legacyColumns)
+		.filter(([_name, kind]) => kind === "json")
+		.map(([name]) => name);
+	for (const name of structured) {
+		yield* sql`alter table ${sql(table)} rename column ${sql(name)} to ${sql(`legacy_${name}`)}`;
+	}
+	const columns = shapeColumns(shapeV12);
+	for (const [name, kind] of Object.entries(columns)) {
+		if (!(name in legacyColumns) || structured.includes(name)) {
+			yield* sql`alter table ${sql(table)} add column ${sql(name)} ${sql.literal(sqlTypes[kind])}`;
+		}
+	}
+	yield* createCollections(namespace, shapeV12);
+	const rows = yield* sql`select * from ${sql(table)} order by admission_order`;
+	const model = modelFromColumns(columns);
+	const saveChildren = yield* makeRecordChildren(namespace, shapeV12);
+	for (const row of rows) {
+		const value = yield* textRecordValue(row, structured);
+		const input = yield* Schema.decodeUnknownEffect(model.insert)({ ...inputColumns(value, shapeV12), "work_id": row.work_id });
+		yield* sql`update ${sql(table)} set ${sql.update(yield* Schema.encodeEffect(model.insert)(input))} where work_id = ${row.work_id}`;
+		yield* saveChildren(String(row.work_id), value, false);
+	}
+	for (const name of structured) {
+		yield* sql`alter table ${sql(table)} drop column ${sql(`legacy_${name}`)}`;
+	}
+});