@yielded/auth-persistence 0.1.0-beta.10

package/dist/internal/storage-tables.mjs

@@ -0,0 +1,387 @@
+import { Schema } from "effect";
+//#region src/internal/storage-tables.ts
+const StorageColumn = Schema.Struct({
+	name: Schema.NonEmptyString,
+	type: Schema.Literals([
+		"text",
+		"integer",
+		"boolean"
+	]),
+	nullable: Schema.optionalKey(Schema.Boolean)
+});
+const StorageTable = Schema.Struct({
+	name: Schema.NonEmptyString,
+	schema: Schema.optionalKey(Schema.NonEmptyString),
+	columns: Schema.Record(Schema.String, StorageColumn),
+	unique: Schema.Array(Schema.Array(Schema.String))
+});
+const text = { type: "text" };
+const integer = { type: "integer" };
+const boolean = { type: "boolean" };
+const optionalText = {
+	...text,
+	nullable: true
+};
+const optionalInteger = {
+	...integer,
+	nullable: true
+};
+const spec = (columns, unique) => ({
+	columns,
+	unique
+});
+/** Logical roles are independent of table names and migration ownership. */
+const storageTables = {
+	subjects: spec({
+		id: text,
+		active: boolean,
+		securityRevision: text
+	}, [["id"]]),
+	identifiers: spec({
+		namespace: text,
+		value: text,
+		subjectId: text,
+		revision: text,
+		verifiedAt: optionalInteger,
+		active: boolean
+	}, [["namespace", "value"]]),
+	credentials: spec({
+		credentialId: text,
+		subjectId: text,
+		revision: text,
+		active: boolean
+	}, [["credentialId"]]),
+	passwords: spec({
+		moduleId: text,
+		subjectId: text,
+		credentialId: text,
+		credentialRevision: text,
+		verifierVersion: text,
+		verifier: text,
+		normalization: text
+	}, [["moduleId", "subjectId"], ["moduleId", "credentialId"]]),
+	passwordAttempts: spec({
+		moduleId: text,
+		action: text,
+		attemptId: text,
+		identifierNamespace: text,
+		identifierValue: text,
+		subjectId: optionalText,
+		credentialId: optionalText,
+		securityRevision: optionalText,
+		credentialRevision: optionalText,
+		verifierVersion: optionalText,
+		identifierBindingRevision: optionalText,
+		admittedAt: integer,
+		deadline: integer,
+		retentionUntil: integer,
+		state: text
+	}, [["moduleId", "attemptId"]]),
+	passwordScopes: spec({
+		moduleId: text,
+		action: text,
+		scopeKind: text,
+		scopeKey: text
+	}, [[
+		"moduleId",
+		"action",
+		"scopeKind",
+		"scopeKey"
+	]]),
+	passwordCharges: spec({
+		moduleId: text,
+		action: text,
+		scopeKind: text,
+		scopeKey: text,
+		attemptId: text,
+		occurredAt: integer,
+		retentionUntil: integer
+	}, [[
+		"moduleId",
+		"action",
+		"scopeKind",
+		"scopeKey",
+		"attemptId"
+	]]),
+	passwordCommands: spec({
+		moduleId: text,
+		commandId: text,
+		action: text,
+		bindingDigest: text,
+		decision: text,
+		retentionUntil: integer
+	}, [["moduleId", "commandId"]]),
+	passwordRegistrations: spec({
+		moduleId: text,
+		requestId: text
+	}, [["moduleId", "requestId"]]),
+	emailCredentials: spec({
+		moduleId: text,
+		subjectId: text,
+		credentialId: text,
+		identifierNamespace: text,
+		identifierValue: text,
+		credentialRevision: text,
+		active: boolean
+	}, [["moduleId", "credentialId"], [
+		"moduleId",
+		"identifierNamespace",
+		"identifierValue"
+	]]),
+	emailCommands: spec({
+		moduleId: text,
+		commandId: text,
+		action: text,
+		bindingDigest: text,
+		retentionUntil: integer
+	}, [["moduleId", "commandId"]]),
+	phoneState: spec({
+		scope: text,
+		state: text,
+		version: text
+	}, [["scope"]]),
+	passkeyCredentials: spec({
+		credentialId: text,
+		subjectId: text,
+		rpId: text,
+		protocolCredentialId: text,
+		credentialKey: text,
+		handleKey: text,
+		userHandle: text,
+		publicKey: text,
+		algorithm: integer,
+		profile: text,
+		credentialRevision: text,
+		active: boolean,
+		primarySignIn: boolean,
+		enrollmentUserVerified: boolean,
+		backupEligible: boolean,
+		backupState: boolean,
+		counter: integer,
+		maximumCounter: integer,
+		name: text,
+		createdAt: integer,
+		lastUsedAt: optionalInteger
+	}, [["credentialId"], ["credentialKey"]]),
+	passkeyOwnership: spec({
+		credentialKey: text,
+		rpId: text,
+		protocolCredentialId: text,
+		subjectId: optionalText,
+		credentialId: optionalText,
+		state: text,
+		version: text,
+		reservationId: optionalText
+	}, [["credentialKey"]]),
+	passkeyHandles: spec({
+		handleKey: text,
+		rpId: text,
+		userHandle: text,
+		subjectId: optionalText,
+		state: text,
+		version: text,
+		reservationId: optionalText
+	}, [["handleKey"], ["rpId", "subjectId"]]),
+	passkeyModules: spec({
+		moduleId: text,
+		active: boolean,
+		policyRevision: text,
+		policy: text
+	}, [["moduleId"]]),
+	passkeyFlows: spec({
+		moduleId: text,
+		flowId: text,
+		commandId: text,
+		purpose: text,
+		state: text,
+		version: text,
+		generation: integer,
+		snapshot: text,
+		policySnapshot: text,
+		requestBindingVerifier: text,
+		requestBindingExpiresAt: integer,
+		issuedAt: integer,
+		expiresAt: integer,
+		retentionUntil: integer,
+		claimId: optionalText,
+		claimedAt: optionalInteger,
+		claimExpiresAt: optionalInteger,
+		credentialSnapshot: optionalText,
+		subjectScope: optionalText,
+		targetScope: optionalText
+	}, [["moduleId", "flowId"], ["moduleId", "commandId"]]),
+	passkeyAdmissions: spec({
+		authorityScope: text,
+		moduleId: text,
+		version: text,
+		ownerMarker: text,
+		admittedAt: optionalInteger
+	}, [["authorityScope", "moduleId"]]),
+	passkeyCharges: spec({
+		moduleId: text,
+		flowId: text,
+		purpose: text,
+		kind: text,
+		scope: text,
+		originalWindowMillis: integer,
+		admittedAt: optionalInteger,
+		retainUntil: optionalInteger,
+		version: text,
+		ownerMarker: text
+	}, [[
+		"moduleId",
+		"flowId",
+		"kind"
+	]]),
+	passkeyCommands: spec({
+		moduleId: text,
+		commandId: text,
+		subjectId: text,
+		credentialId: text,
+		intent: text,
+		decision: text,
+		retentionUntil: integer,
+		version: text
+	}, [["moduleId", "commandId"]]),
+	proofRequests: spec({
+		moduleId: text,
+		requestId: text,
+		fingerprint: text,
+		proofId: text,
+		purpose: text,
+		keyId: text,
+		createdAt: integer,
+		retentionUntil: integer,
+		receipt: text
+	}, [["moduleId", "requestId"]]),
+	proofSeries: spec({
+		moduleId: text,
+		purpose: text,
+		scopeKey: text,
+		activeProofId: optionalText,
+		lastIssueAt: optionalInteger,
+		version: text
+	}, [[
+		"moduleId",
+		"purpose",
+		"scopeKey"
+	]]),
+	proofGenerations: spec({
+		moduleId: text,
+		purpose: text,
+		proofId: text,
+		requestId: text,
+		seriesKey: text,
+		deliveryId: text,
+		binding: text,
+		verifierKeyId: text,
+		verifierDigest: text,
+		issuedAt: integer,
+		expiresAt: integer,
+		version: text,
+		state: text,
+		sendCount: integer,
+		deliveryState: text,
+		claimVersion: optionalText,
+		claimDeadline: optionalInteger,
+		retryAt: optionalInteger,
+		deliveryRetryMillis: integer,
+		retentionUntil: integer,
+		fingerprint: text
+	}, [["moduleId", "proofId"], ["moduleId", "deliveryId"]]),
+	proofContinuations: spec({
+		moduleId: text,
+		purpose: text,
+		continuationId: text,
+		digest: text,
+		proofId: text,
+		seriesKey: text,
+		binding: text,
+		expiresAt: integer,
+		consumed: boolean,
+		version: text,
+		retentionUntil: integer
+	}, [["moduleId", "continuationId"], ["moduleId", "digest"]]),
+	proofScopes: spec({
+		moduleId: text,
+		purpose: text,
+		action: text,
+		scopeKind: text,
+		scopeKey: text
+	}, [[
+		"moduleId",
+		"purpose",
+		"action",
+		"scopeKind",
+		"scopeKey"
+	]]),
+	proofAbuse: spec({
+		moduleId: text,
+		purpose: text,
+		action: text,
+		scopeKind: text,
+		scopeKey: text,
+		commandId: text,
+		occurredAt: integer,
+		retentionUntil: integer
+	}, [[
+		"moduleId",
+		"action",
+		"scopeKind",
+		"scopeKey",
+		"commandId"
+	]]),
+	proofFailures: spec({
+		moduleId: text,
+		purpose: text,
+		seriesKey: text,
+		commandId: text,
+		occurredAt: integer,
+		retentionUntil: integer
+	}, [[
+		"moduleId",
+		"seriesKey",
+		"commandId"
+	]]),
+	proofCommands: spec({
+		moduleId: text,
+		commandId: text,
+		kind: text,
+		decision: text,
+		retentionUntil: integer
+	}, [["moduleId", "commandId"]]),
+	sessions: spec({
+		sessionId: text,
+		subjectId: text,
+		digest: text,
+		version: text,
+		securityRevision: text,
+		issuedAt: integer,
+		expiresAt: integer,
+		absoluteExpiresAt: integer,
+		record: text
+	}, [["sessionId"], ["digest"]]),
+	sessionFlows: spec({
+		flowId: text,
+		subjectId: text,
+		state: text,
+		pendingDigest: optionalText,
+		dedupUntil: integer
+	}, [["flowId"]])
+};
+const tableDefinition = (role, name, subjectType = "text") => {
+	const table = storageTables[role];
+	return {
+		name,
+		columns: Object.fromEntries(Object.entries(table.columns).map(([key, column]) => [key, {
+			...column,
+			name: key.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase()),
+			...key === "subjectId" ? { type: subjectType } : {}
+		}])),
+		unique: table.unique
+	};
+};
+//#endregion
+export { StorageColumn, StorageTable, storageTables, tableDefinition };
+
+//# sourceMappingURL=storage-tables.mjs.map

package/dist/internal/storage-tables.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-tables.mjs","names":[],"sources":["../../src/internal/storage-tables.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const StorageColumn = Schema.Struct({\n  name: Schema.NonEmptyString,\n  type: Schema.Literals([\"text\", \"integer\", \"boolean\"]),\n  nullable: Schema.optionalKey(Schema.Boolean),\n});\n\nexport const StorageTable = Schema.Struct({\n  name: Schema.NonEmptyString,\n  schema: Schema.optionalKey(Schema.NonEmptyString),\n  columns: Schema.Record(Schema.String, StorageColumn),\n  unique: Schema.Array(Schema.Array(Schema.String)),\n});\n\nexport type StorageTable = typeof StorageTable.Type;\n\nconst text = { type: \"text\" as const };\nconst integer = { type: \"integer\" as const };\nconst boolean = { type: \"boolean\" as const };\nconst optionalText = { ...text, nullable: true };\nconst optionalInteger = { ...integer, nullable: true };\n\nconst spec = <C extends Readonly<Record<string, Omit<typeof StorageColumn.Type, \"name\">>>>(\n  columns: C,\n  unique: ReadonlyArray<ReadonlyArray<Extract<keyof C, string>>>,\n) => ({ columns, unique });\n\n/** Logical roles are independent of table names and migration ownership. */\nexport const storageTables = {\n  subjects: spec({ id: text, active: boolean, securityRevision: text }, [[\"id\"]]),\n  identifiers: spec(\n    {\n      namespace: text,\n      value: text,\n      subjectId: text,\n      revision: text,\n      verifiedAt: optionalInteger,\n      active: boolean,\n    },\n    [[\"namespace\", \"value\"]],\n  ),\n  credentials: spec({ credentialId: text, subjectId: text, revision: text, active: boolean }, [\n    [\"credentialId\"],\n  ]),\n  passwords: spec(\n    {\n      moduleId: text,\n      subjectId: text,\n      credentialId: text,\n      credentialRevision: text,\n      verifierVersion: text,\n      verifier: text,\n      normalization: text,\n    },\n    [\n      [\"moduleId\", \"subjectId\"],\n      [\"moduleId\", \"credentialId\"],\n    ],\n  ),\n  passwordAttempts: spec(\n    {\n      moduleId: text,\n      action: text,\n      attemptId: text,\n      identifierNamespace: text,\n      identifierValue: text,\n      subjectId: optionalText,\n      credentialId: optionalText,\n      securityRevision: optionalText,\n      credentialRevision: optionalText,\n      verifierVersion: optionalText,\n      identifierBindingRevision: optionalText,\n      admittedAt: integer,\n      deadline: integer,\n      retentionUntil: integer,\n      state: text,\n    },\n    [[\"moduleId\", \"attemptId\"]],\n  ),\n  passwordScopes: spec({ moduleId: text, action: text, scopeKind: text, scopeKey: text }, [\n    [\"moduleId\", \"action\", \"scopeKind\", \"scopeKey\"],\n  ]),\n  passwordCharges: spec(\n    {\n      moduleId: text,\n      action: text,\n      scopeKind: text,\n      scopeKey: text,\n      attemptId: text,\n      occurredAt: integer,\n      retentionUntil: integer,\n    },\n    [[\"moduleId\", \"action\", \"scopeKind\", \"scopeKey\", \"attemptId\"]],\n  ),\n  passwordCommands: spec(\n    {\n      moduleId: text,\n      commandId: text,\n      action: text,\n      bindingDigest: text,\n      decision: text,\n      retentionUntil: integer,\n    },\n    [[\"moduleId\", \"commandId\"]],\n  ),\n  passwordRegistrations: spec({ moduleId: text, requestId: text }, [[\"moduleId\", \"requestId\"]]),\n  emailCredentials: spec(\n    {\n      moduleId: text,\n      subjectId: text,\n      credentialId: text,\n      identifierNamespace: text,\n      identifierValue: text,\n      credentialRevision: text,\n      active: boolean,\n    },\n    [\n      [\"moduleId\", \"credentialId\"],\n      [\"moduleId\", \"identifierNamespace\", \"identifierValue\"],\n    ],\n  ),\n  emailCommands: spec(\n    { moduleId: text, commandId: text, action: text, bindingDigest: text, retentionUntil: integer },\n    [[\"moduleId\", \"commandId\"]],\n  ),\n  phoneState: spec({ scope: text, state: text, version: text }, [[\"scope\"]]),\n  passkeyCredentials: spec(\n    {\n      credentialId: text,\n      subjectId: text,\n      rpId: text,\n      protocolCredentialId: text,\n      credentialKey: text,\n      handleKey: text,\n      userHandle: text,\n      publicKey: text,\n      algorithm: integer,\n      profile: text,\n      credentialRevision: text,\n      active: boolean,\n      primarySignIn: boolean,\n      enrollmentUserVerified: boolean,\n      backupEligible: boolean,\n      backupState: boolean,\n      counter: integer,\n      maximumCounter: integer,\n      name: text,\n      createdAt: integer,\n      lastUsedAt: optionalInteger,\n    },\n    [[\"credentialId\"], [\"credentialKey\"]],\n  ),\n  passkeyOwnership: spec(\n    {\n      credentialKey: text,\n      rpId: text,\n      protocolCredentialId: text,\n      subjectId: optionalText,\n      credentialId: optionalText,\n      state: text,\n      version: text,\n      reservationId: optionalText,\n    },\n    [[\"credentialKey\"]],\n  ),\n  passkeyHandles: spec(\n    {\n      handleKey: text,\n      rpId: text,\n      userHandle: text,\n      subjectId: optionalText,\n      state: text,\n      version: text,\n      reservationId: optionalText,\n    },\n    [[\"handleKey\"], [\"rpId\", \"subjectId\"]],\n  ),\n  passkeyModules: spec(\n    {\n      moduleId: text,\n      active: boolean,\n      policyRevision: text,\n      policy: text,\n    },\n    [[\"moduleId\"]],\n  ),\n  passkeyFlows: spec(\n    {\n      moduleId: text,\n      flowId: text,\n      commandId: text,\n      purpose: text,\n      state: text,\n      version: text,\n      generation: integer,\n      snapshot: text,\n      policySnapshot: text,\n      requestBindingVerifier: text,\n      requestBindingExpiresAt: integer,\n      issuedAt: integer,\n      expiresAt: integer,\n      retentionUntil: integer,\n      claimId: optionalText,\n      claimedAt: optionalInteger,\n      claimExpiresAt: optionalInteger,\n      credentialSnapshot: optionalText,\n      subjectScope: optionalText,\n      targetScope: optionalText,\n    },\n    [\n      [\"moduleId\", \"flowId\"],\n      [\"moduleId\", \"commandId\"],\n    ],\n  ),\n  passkeyAdmissions: spec(\n    {\n      authorityScope: text,\n      moduleId: text,\n      version: text,\n      ownerMarker: text,\n      admittedAt: optionalInteger,\n    },\n    [[\"authorityScope\", \"moduleId\"]],\n  ),\n  passkeyCharges: spec(\n    {\n      moduleId: text,\n      flowId: text,\n      purpose: text,\n      kind: text,\n      scope: text,\n      originalWindowMillis: integer,\n      admittedAt: optionalInteger,\n      retainUntil: optionalInteger,\n      version: text,\n      ownerMarker: text,\n    },\n    [[\"moduleId\", \"flowId\", \"kind\"]],\n  ),\n  passkeyCommands: spec(\n    {\n      moduleId: text,\n      commandId: text,\n      subjectId: text,\n      credentialId: text,\n      intent: text,\n      decision: text,\n      retentionUntil: integer,\n      version: text,\n    },\n    [[\"moduleId\", \"commandId\"]],\n  ),\n  proofRequests: spec(\n    {\n      moduleId: text,\n      requestId: text,\n      fingerprint: text,\n      proofId: text,\n      purpose: text,\n      keyId: text,\n      createdAt: integer,\n      retentionUntil: integer,\n      receipt: text,\n    },\n    [[\"moduleId\", \"requestId\"]],\n  ),\n  proofSeries: spec(\n    {\n      moduleId: text,\n      purpose: text,\n      scopeKey: text,\n      activeProofId: optionalText,\n      lastIssueAt: optionalInteger,\n      version: text,\n    },\n    [[\"moduleId\", \"purpose\", \"scopeKey\"]],\n  ),\n  proofGenerations: spec(\n    {\n      moduleId: text,\n      purpose: text,\n      proofId: text,\n      requestId: text,\n      seriesKey: text,\n      deliveryId: text,\n      binding: text,\n      verifierKeyId: text,\n      verifierDigest: text,\n      issuedAt: integer,\n      expiresAt: integer,\n      version: text,\n      state: text,\n      sendCount: integer,\n      deliveryState: text,\n      claimVersion: optionalText,\n      claimDeadline: optionalInteger,\n      retryAt: optionalInteger,\n      deliveryRetryMillis: integer,\n      retentionUntil: integer,\n      fingerprint: text,\n    },\n    [\n      [\"moduleId\", \"proofId\"],\n      [\"moduleId\", \"deliveryId\"],\n    ],\n  ),\n  proofContinuations: spec(\n    {\n      moduleId: text,\n      purpose: text,\n      continuationId: text,\n      digest: text,\n      proofId: text,\n      seriesKey: text,\n      binding: text,\n      expiresAt: integer,\n      consumed: boolean,\n      version: text,\n      retentionUntil: integer,\n    },\n    [\n      [\"moduleId\", \"continuationId\"],\n      [\"moduleId\", \"digest\"],\n    ],\n  ),\n  proofScopes: spec(\n    { moduleId: text, purpose: text, action: text, scopeKind: text, scopeKey: text },\n    [[\"moduleId\", \"purpose\", \"action\", \"scopeKind\", \"scopeKey\"]],\n  ),\n  proofAbuse: spec(\n    {\n      moduleId: text,\n      purpose: text,\n      action: text,\n      scopeKind: text,\n      scopeKey: text,\n      commandId: text,\n      occurredAt: integer,\n      retentionUntil: integer,\n    },\n    [[\"moduleId\", \"action\", \"scopeKind\", \"scopeKey\", \"commandId\"]],\n  ),\n  proofFailures: spec(\n    {\n      moduleId: text,\n      purpose: text,\n      seriesKey: text,\n      commandId: text,\n      occurredAt: integer,\n      retentionUntil: integer,\n    },\n    [[\"moduleId\", \"seriesKey\", \"commandId\"]],\n  ),\n  proofCommands: spec(\n    { moduleId: text, commandId: text, kind: text, decision: text, retentionUntil: integer },\n    [[\"moduleId\", \"commandId\"]],\n  ),\n  sessions: spec(\n    {\n      sessionId: text,\n      subjectId: text,\n      digest: text,\n      version: text,\n      securityRevision: text,\n      issuedAt: integer,\n      expiresAt: integer,\n      absoluteExpiresAt: integer,\n      record: text,\n    },\n    [[\"sessionId\"], [\"digest\"]],\n  ),\n  sessionFlows: spec(\n    {\n      flowId: text,\n      subjectId: text,\n      state: text,\n      pendingDigest: optionalText,\n      dedupUntil: integer,\n    },\n    [[\"flowId\"]],\n  ),\n} as const;\n\nexport type StorageRole = keyof typeof storageTables;\n\nexport const tableDefinition = (\n  role: StorageRole,\n  name: string,\n  subjectType: \"text\" | \"integer\" = \"text\",\n): StorageTable => {\n  const table = storageTables[role];\n\n  return {\n    name,\n    columns: Object.fromEntries(\n      Object.entries(table.columns).map(([key, column]) => [\n        key,\n        {\n          ...column,\n          name: key.replace(/[A-Z]/g, (letter) => \"_\" + letter.toLowerCase()),\n          ...(key === \"subjectId\" ? { type: subjectType } : {}),\n        },\n      ]),\n    ),\n    unique: table.unique,\n  };\n};\n"],"mappings":"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"}

package/dist/internal/storage-validation.mjs

@@ -0,0 +1,58 @@
+import { PersistenceConfigurationError } from "./configuration.mjs";
+import { Effect, Schema } from "effect";
+//#region src/internal/storage-validation.ts
+const Column = Schema.Struct({
+	name: Schema.String,
+	pk: Schema.Int
+});
+const Index = Schema.Struct({
+	name: Schema.String,
+	unique: Schema.Int,
+	partial: Schema.Int
+});
+const IndexColumn = Schema.Struct({ name: Schema.NullOr(Schema.String) });
+const PgColumns = Schema.Array(Schema.Struct({ name: Schema.String }));
+const PgKeys = Schema.Array(Schema.Struct({ columns: Schema.Array(Schema.String) }));
+const quote = (value) => "\"" + value.replaceAll("\"", "\"\"") + "\"";
+const qualifiedTableName = (table) => (table.schema === void 0 ? "" : quote(table.schema) + ".") + quote(table.name);
+/** Validate physical uniqueness before the first authentication operation. A
+* partial or expression index cannot establish these unconditional guarantees. */
+const validateStorage = (client, dialect, table, required) => Effect.gen(function* () {
+	const physicalKeys = yield* dialect === "sqlite" ? Effect.gen(function* () {
+		if (table.schema !== void 0 && table.schema !== "main") return yield* PersistenceConfigurationError.make({ reason: "SQLite storage must belong to the main database" });
+		const columns = yield* client`select name, pk from pragma_table_info(${table.name})`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Column))));
+		for (const column of Object.values(table.columns)) if (!columns.some((actual) => actual.name === column.name)) return yield* PersistenceConfigurationError.make({ reason: `Missing SQL column ${table.name}.${column.name}` });
+		const keys = [];
+		const primary = columns.filter((column) => column.pk > 0).sort((a, b) => a.pk - b.pk);
+		if (primary.length > 0) keys.push(primary.map((column) => column.name));
+		const indexes = yield* client`select name, "unique", partial from pragma_index_list(${table.name})`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Index))));
+		for (const index of indexes) {
+			if (index.unique !== 1 || index.partial !== 0) continue;
+			const columns = yield* client`select name from pragma_index_info(${index.name})`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(IndexColumn))));
+			if (columns.every((column) => column.name !== null)) keys.push(columns.flatMap((column) => column.name === null ? [] : [column.name]));
+		}
+		return keys;
+	}) : Effect.gen(function* () {
+		const relation = qualifiedTableName(table);
+		const columns = yield* client`select attname as name from pg_attribute where attrelid = to_regclass(${relation}) and attnum > 0 and not attisdropped`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(PgColumns)));
+		for (const column of Object.values(table.columns)) if (!columns.some((actual) => actual.name === column.name)) return yield* PersistenceConfigurationError.make({ reason: `Missing SQL column ${relation}.${column.name}` });
+		return (yield* client`
+          select array_agg(a.attname order by k.ordinality) as columns
+          from pg_index i
+          cross join lateral unnest(i.indkey) with ordinality as k(attnum, ordinality)
+          join pg_attribute a on a.attrelid = i.indrelid and a.attnum = k.attnum
+          where i.indrelid = to_regclass(${relation}) and i.indisunique and i.indisvalid
+            and i.indimmediate and i.indpred is null and i.indexprs is null
+            and k.ordinality <= i.indnkeyatts
+          group by i.indexrelid
+        `.pipe(Effect.flatMap(Schema.decodeUnknownEffect(PgKeys)))).map((index) => index.columns);
+	});
+	for (const keys of required) {
+		const columns = keys.map((key) => table.columns[key]?.name);
+		if (columns.some((column) => column === void 0) || !physicalKeys.some((actual) => actual.length === columns.length && actual.every((column) => columns.includes(column)))) return yield* PersistenceConfigurationError.make({ reason: `Missing unique key on ${table.name} (${keys.join(", ")})` });
+	}
+}).pipe(Effect.mapError((error) => Schema.is(PersistenceConfigurationError)(error) ? error : PersistenceConfigurationError.make({ reason: `Cannot validate SQL storage for ${table.name}` })));
+//#endregion
+export { qualifiedTableName, validateStorage };
+
+//# sourceMappingURL=storage-validation.mjs.map

package/dist/internal/storage-validation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-validation.mjs","names":[],"sources":["../../src/internal/storage-validation.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\nimport type { SqlClient } from \"effect/unstable/sql/SqlClient\";\n\nimport { PersistenceConfigurationError } from \"./configuration\";\nimport type { StorageTable } from \"./storage-tables\";\n\nconst Column = Schema.Struct({ name: Schema.String, pk: Schema.Int });\nconst Index = Schema.Struct({ name: Schema.String, unique: Schema.Int, partial: Schema.Int });\nconst IndexColumn = Schema.Struct({ name: Schema.NullOr(Schema.String) });\nconst PgColumns = Schema.Array(Schema.Struct({ name: Schema.String }));\nconst PgKeys = Schema.Array(Schema.Struct({ columns: Schema.Array(Schema.String) }));\nconst quote = (value: string) => '\"' + value.replaceAll('\"', '\"\"') + '\"';\n\nexport const qualifiedTableName = (table: Pick<StorageTable, \"name\" | \"schema\">) =>\n  (table.schema === undefined ? \"\" : quote(table.schema) + \".\") + quote(table.name);\n\n/** Validate physical uniqueness before the first authentication operation. A\n * partial or expression index cannot establish these unconditional guarantees. */\nexport const validateStorage = (\n  client: SqlClient,\n  dialect: \"pg\" | \"sqlite\",\n  table: StorageTable,\n  required: ReadonlyArray<ReadonlyArray<string>>,\n) =>\n  Effect.gen(function* () {\n    const physicalKeys: ReadonlyArray<ReadonlyArray<string>> = yield* dialect === \"sqlite\"\n      ? Effect.gen(function* () {\n          if (table.schema !== undefined && table.schema !== \"main\")\n            return yield* PersistenceConfigurationError.make({\n              reason: \"SQLite storage must belong to the main database\",\n            });\n\n          const columns = yield* client`select name, pk from pragma_table_info(${table.name})`.pipe(\n            Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Column))),\n          );\n\n          for (const column of Object.values(table.columns)) {\n            if (!columns.some((actual) => actual.name === column.name))\n              return yield* PersistenceConfigurationError.make({\n                reason: `Missing SQL column ${table.name}.${column.name}`,\n              });\n          }\n          const keys: string[][] = [];\n          const primary = columns.filter((column) => column.pk > 0).sort((a, b) => a.pk - b.pk);\n\n          if (primary.length > 0) keys.push(primary.map((column) => column.name));\n\n          const indexes =\n            yield* client`select name, \"unique\", partial from pragma_index_list(${table.name})`.pipe(\n              Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Index))),\n            );\n\n          for (const index of indexes) {\n            if (index.unique !== 1 || index.partial !== 0) continue;\n\n            const columns = yield* client`select name from pragma_index_info(${index.name})`.pipe(\n              Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(IndexColumn))),\n            );\n\n            if (columns.every((column) => column.name !== null))\n              keys.push(columns.flatMap((column) => (column.name === null ? [] : [column.name])));\n          }\n\n          return keys;\n        })\n      : Effect.gen(function* () {\n          const relation = qualifiedTableName(table);\n\n          const columns =\n            yield* client`select attname as name from pg_attribute where attrelid = to_regclass(${relation}) and attnum > 0 and not attisdropped`.pipe(\n              Effect.flatMap(Schema.decodeUnknownEffect(PgColumns)),\n            );\n\n          for (const column of Object.values(table.columns)) {\n            if (!columns.some((actual) => actual.name === column.name))\n              return yield* PersistenceConfigurationError.make({\n                reason: `Missing SQL column ${relation}.${column.name}`,\n              });\n          }\n\n          const indexes = yield* client`\n          select array_agg(a.attname order by k.ordinality) as columns\n          from pg_index i\n          cross join lateral unnest(i.indkey) with ordinality as k(attnum, ordinality)\n          join pg_attribute a on a.attrelid = i.indrelid and a.attnum = k.attnum\n          where i.indrelid = to_regclass(${relation}) and i.indisunique and i.indisvalid\n            and i.indimmediate and i.indpred is null and i.indexprs is null\n            and k.ordinality <= i.indnkeyatts\n          group by i.indexrelid\n        `.pipe(Effect.flatMap(Schema.decodeUnknownEffect(PgKeys)));\n\n          return indexes.map((index) => index.columns);\n        });\n\n    for (const keys of required) {\n      const columns = keys.map((key) => table.columns[key]?.name);\n\n      if (\n        columns.some((column) => column === undefined) ||\n        !physicalKeys.some(\n          (actual) =>\n            actual.length === columns.length && actual.every((column) => columns.includes(column)),\n        )\n      )\n        return yield* PersistenceConfigurationError.make({\n          reason: `Missing unique key on ${table.name} (${keys.join(\", \")})`,\n        });\n    }\n  }).pipe(\n    Effect.mapError((error) =>\n      Schema.is(PersistenceConfigurationError)(error)\n        ? error\n        : PersistenceConfigurationError.make({\n            reason: `Cannot validate SQL storage for ${table.name}`,\n          }),\n    ),\n  );\n"],"mappings":"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"}

package/dist/internal/transaction-execution-kernel.d.mts

@@ -0,0 +1,38 @@
+import { TransactionNativeDatabase, TransactionOwner, makeTransactionKernel } from "./transaction-kernel.mjs";
+import { Context, Effect } from "effect";
+import { CurrentCommitJournal, HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
+import { Statement } from "effect/unstable/sql/Statement";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlError$1 from "effect/unstable/sql/SqlError";
+//#region src/internal/transaction-execution-kernel.d.ts
+export interface TransactionTargetConfiguration<Failure> {
+  readonly mode: "interactive" | "synchronous" | "batch";
+  readonly dialect: "pg" | "mysql" | "sqlite";
+  readonly locking: boolean;
+  readonly standaloneGuard: (database: any) => Effect.Effect<void, Failure>;
+  readonly transaction?: <A, E, R>(database: any, body: (transaction: any) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError$1.SqlError | Failure, R>;
+}
+export type TransactionCoordinatorError<E, Failure> = E | Failure | HookConfigurationError | SqlError$1.SqlError;
+export interface TransactionBound<Failure> {
+  readonly owner: TransactionOwner<Failure>;
+  used: boolean;
+  poisoned: boolean;
+  active: boolean;
+  inFlight: number;
+}
+export interface TransactionExecution<Failure, OwnerId, Requirements = LifecycleHooks> {
+  readonly bound: boolean;
+  readonly active: () => boolean;
+  readonly admit: Effect.Effect<void, Failure>;
+  readonly poison: () => void;
+  readonly run: <A, E, R>(body: Effect.Effect<A, E, R>, mutation?: boolean) => Effect.Effect<A, Failure, Exclude<R, OwnerId | CurrentCommitJournal> | Requirements>;
+}
+export declare const makeTransactionExecutionKernel: (transactions: Pick<ReturnType<typeof makeTransactionKernel>, "makeTransactionOwner" | "reportTransactionFailure">) => {
+  sqlClientTransactionStandaloneGuard: <Failure>(unavailable: () => Failure, database: {
+    readonly $client: Pick<SqlClient.SqlClient, "transactionService">;
+  }) => Effect.Effect<void, Failure, never>;
+  makeTransactionExecution: <Failure, OwnerId>(ownerTag: Context.Key<OwnerId, TransactionOwner<Failure>>, database: TransactionNativeDatabase, configuration: TransactionTargetConfiguration<Failure>, unavailable: () => Failure, nonce: () => string, bound?: TransactionBound<Failure>) => TransactionExecution<Failure, OwnerId>;
+  coordinateTransactionOwner: <Failure, OwnerId, Resources, AllocationError, Services, Transaction, A, E, R>(database: TransactionNativeDatabase, ownerTag: Context.Key<OwnerId, TransactionOwner<Failure>>, configuration: TransactionTargetConfiguration<Failure>, allocate: Effect.Effect<Resources, AllocationError>, unavailable: () => Failure, nonce: () => string, services: (execution: TransactionExecution<Failure, OwnerId>, resources: Resources) => Services, owner: (transaction: Transaction, services: Services, append: (statement: Statement<any>) => void) => Effect.Effect<A, E, R>) => Effect.Effect<A, TransactionCoordinatorError<E, Failure>, Exclude<R, CurrentCommitJournal> | LifecycleHooks>;
+};
+//#endregion
+//# sourceMappingURL=transaction-execution-kernel.d.mts.map

package/dist/internal/transaction-execution-kernel.mjs

@@ -0,0 +1,116 @@
+import { requireStandalone } from "./standalone.mjs";
+import { Context, Effect } from "effect";
+import { CurrentCommitJournal, coordinateCommit, hasCommitScope } from "@yielded/auth/Hooks";
+//#region src/internal/transaction-execution-kernel.ts
+const makeTransactionExecutionKernel = (transactions) => {
+	const { makeTransactionOwner, reportTransactionFailure } = transactions;
+	const sqlClientTransactionStandaloneGuard = (unavailable, database) => requireStandalone(unavailable, database.$client);
+	const makeTransactionExecution = (ownerTag, database, configuration, unavailable, nonce, bound) => {
+		const invariant = (value) => {
+			if (!value) throw unavailable();
+		};
+		return {
+			bound: bound !== void 0,
+			active: () => bound === void 0 || bound.active,
+			admit: bound !== void 0 ? Effect.suspend(() => bound.active ? Effect.void : Effect.fail(unavailable())) : Effect.gen(function* () {
+				if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
+				yield* configuration.standaloneGuard(database);
+			}),
+			poison: () => {
+				if (bound !== void 0) bound.poisoned = true;
+			},
+			run: (body, mutation = true) => {
+				return Effect.suspend(() => {
+					let entered = false;
+					return (bound !== void 0 ? Effect.gen(function* () {
+						if (!bound.active) return yield* Effect.fail(unavailable());
+						entered = true;
+						bound.inFlight++;
+						if (!mutation) return yield* Effect.provideContext(body, Context.make(ownerTag, bound.owner).pipe(Context.add(CurrentCommitJournal, bound.owner.journal)));
+						invariant(!bound.used && !bound.poisoned);
+						bound.used = true;
+						return (yield* coordinateCommit((journal) => Effect.gen(function* () {
+							bound.owner.guards.push(journal.prepare(void 0));
+							return yield* Effect.provideContext(body, Context.make(ownerTag, {
+								...bound.owner,
+								journal
+							}).pipe(Context.add(CurrentCommitJournal, journal)));
+						}), { mode: configuration.mode })).value;
+					}).pipe(Effect.onExit((exit) => Effect.sync(() => {
+						if (entered) bound.inFlight--;
+						if (exit._tag === "Failure") bound.poisoned = true;
+					}))) : Effect.gen(function* () {
+						if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
+						yield* configuration.standaloneGuard(database);
+						const marker = nonce();
+						return (yield* coordinateCommit((journal) => {
+							const run = (tx) => Effect.gen(function* () {
+								const owner = makeTransactionOwner(tx, journal, marker, unavailable, {
+									client: database.$client,
+									batch: configuration.mode === "batch",
+									locking: configuration.locking,
+									mysql: configuration.dialect === "mysql",
+									dialect: configuration.dialect
+								});
+								const value = yield* Effect.provideContext(body, Context.make(ownerTag, owner).pipe(Context.add(CurrentCommitJournal, journal)));
+								yield* owner.finish();
+								if (configuration.mode === "batch") yield* tx.$client.batch(owner.statements);
+								return value;
+							});
+							return configuration.mode === "batch" ? run(database) : configuration.transaction !== void 0 ? configuration.transaction(database, run) : database.transaction(run);
+						}, { mode: configuration.mode })).value;
+					})).pipe((operation) => reportTransactionFailure(operation, unavailable), Effect.mapError(unavailable), Effect.catchDefect(() => Effect.fail(unavailable())));
+				});
+			}
+		};
+	};
+	const coordinateTransactionOwner = (database, ownerTag, configuration, allocate, unavailable, nonce, services, owner) => {
+		return Effect.gen(function* () {
+			if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
+			yield* configuration.standaloneGuard(database);
+			const resources = yield* allocate.pipe((operation) => reportTransactionFailure(operation, unavailable), Effect.mapError(unavailable), Effect.catchDefect(() => Effect.fail(unavailable())));
+			const marker = nonce();
+			return (yield* coordinateCommit((journal) => {
+				const run = (tx) => Effect.gen(function* () {
+					const state = makeTransactionOwner(tx, journal, marker, unavailable, {
+						client: database.$client,
+						batch: configuration.mode === "batch",
+						dialect: configuration.dialect,
+						mysql: configuration.dialect === "mysql",
+						locking: configuration.locking
+					});
+					const bound = {
+						owner: state,
+						used: false,
+						poisoned: false,
+						active: true,
+						inFlight: 0
+					};
+					return yield* Effect.gen(function* () {
+						const value = yield* owner(tx, services(makeTransactionExecution(ownerTag, tx, configuration, unavailable, nonce, bound), resources), (statement) => {
+							if (!bound.active) throw unavailable();
+							state.statements.push(statement);
+						});
+						bound.active = false;
+						if (bound.poisoned || bound.inFlight !== 0) return yield* Effect.fail(unavailable());
+						yield* state.finish();
+						if (configuration.mode === "batch") yield* tx.$client.batch(state.statements);
+						return value;
+					}).pipe(Effect.ensuring(Effect.sync(() => {
+						bound.active = false;
+					})));
+				});
+				return configuration.mode === "batch" ? run(database) : configuration.transaction !== void 0 ? configuration.transaction(database, run) : database.transaction(run);
+			}, { mode: configuration.mode })).value;
+		});
+	};
+	return {
+		sqlClientTransactionStandaloneGuard,
+		makeTransactionExecution,
+		coordinateTransactionOwner
+	};
+};
+//#endregion
+export { makeTransactionExecutionKernel };
+
+//# sourceMappingURL=transaction-execution-kernel.mjs.map