appflare 0.2.24 → 0.2.26

package/schema.ts

@@ -1,415 +1,415 @@
-export type ColumnType = "int" | "string" | "boolean" | "date";
-
-export type ColumnBuilderOptions = {
-	sqlName?: string;
-	length?: number;
-};
-
-export type PrimaryKeyOptions = {
-	autoIncrement?: boolean;
-};
-
-export type ForeignKeyAction =
-	| "cascade"
-	| "set null"
-	| "set default"
-	| "restrict"
-	| "no action";
-
-export type RelationOneOptions = {
-	referenceField?: string;
-	field?: string;
-	fkType?: ColumnType;
-	sqlName?: string;
-	notNull?: boolean;
-	nullable?: boolean;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type RelationManyOptions = {
-	referenceField?: string;
-	field?: string;
-	fkType?: ColumnType;
-	sqlName?: string;
-	notNull?: boolean;
-	nullable?: boolean;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type RelationManyToManyOptions = {
-	referenceField?: string;
-	targetReferenceField?: string;
-	junctionTable?: string;
-	sourceField?: string;
-	targetField?: string;
-	sourceSqlName?: string;
-	targetSqlName?: string;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type ColumnReference = {
-	table: string;
-	column: string;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type ColumnDefinition = {
-	kind: "column";
-	type: ColumnType;
-	sqlName?: string;
-	length?: number;
-	notNull?: boolean;
-	nullable?: boolean;
-	primaryKey?: boolean;
-	autoIncrement?: boolean;
-	/** When true the column stores a UUID generated at runtime (string type). */
-	uuidPrimaryKey?: boolean;
-	unique?: true | { name?: string };
-	index?: true | { name?: string };
-	sqlDefault?: unknown;
-	/** When true, the SQL column gets DEFAULT CURRENT_TIMESTAMP and runtime inserts use `new Date()`. */
-	nowDefault?: boolean;
-	runtimeDefaultFn?: () => unknown;
-	references?: ColumnReference;
-};
-
-export type OneRelationDefinition = {
-	kind: "relation";
-	relation: "one";
-	targetTable: string;
-	field?: string;
-	referenceField?: string;
-	fkType?: ColumnType;
-	sqlName?: string;
-	notNull?: boolean;
-	nullable?: boolean;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type ManyRelationDefinition = {
-	kind: "relation";
-	relation: "many";
-	targetTable: string;
-	field?: string;
-	referenceField?: string;
-	fkType?: ColumnType;
-	sqlName?: string;
-	notNull?: boolean;
-	nullable?: boolean;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type ManyToManyRelationDefinition = {
-	kind: "relation";
-	relation: "manyToMany";
-	targetTable: string;
-	referenceField?: string;
-	targetReferenceField?: string;
-	junctionTable?: string;
-	sourceField?: string;
-	targetField?: string;
-	sourceSqlName?: string;
-	targetSqlName?: string;
-	onDelete?: ForeignKeyAction;
-	onUpdate?: ForeignKeyAction;
-};
-
-export type RelationDefinition =
-	| OneRelationDefinition
-	| ManyRelationDefinition
-	| ManyToManyRelationDefinition;
-
-export type TableOptions = {
-	sqlName?: string;
-};
-
-export type TableShape = Record<string, ColumnBuilder | RelationDefinition>;
-
-export type TableDefinition = {
-	kind: "table";
-	sqlName?: string;
-	columns: Record<string, ColumnDefinition>;
-	relations: Record<string, RelationDefinition>;
-};
-
-export type SchemaDefinition = {
-	kind: "schema";
-	tables: Record<string, TableDefinition>;
-};
-
-export class ColumnBuilder {
-	private definition: ColumnDefinition;
-
-	public constructor(
-		typeOrDefinition: ColumnType | ColumnDefinition,
-		options: ColumnBuilderOptions = {},
-	) {
-		if (typeof typeOrDefinition === "string") {
-			this.definition = {
-				kind: "column",
-				type: typeOrDefinition,
-				sqlName: options.sqlName,
-				length: options.length,
-			};
-			return;
-		}
-
-		this.definition = {
-			...typeOrDefinition,
-		};
-	}
-
-	private with(patch: Partial<ColumnDefinition>): ColumnBuilder {
-		return new ColumnBuilder({
-			...this.definition,
-			...patch,
-		});
-	}
-
-	public sql(name: string): ColumnBuilder {
-		return this.with({ sqlName: name });
-	}
-
-	public notNull(): ColumnBuilder {
-		return this.with({ notNull: true, nullable: false });
-	}
-
-	public nullable(): ColumnBuilder {
-		return this.with({ nullable: true, notNull: false });
-	}
-
-	public primaryKey(options: PrimaryKeyOptions = {}): ColumnBuilder {
-		return this.with({
-			primaryKey: true,
-			autoIncrement: options.autoIncrement ?? this.definition.autoIncrement,
-		});
-	}
-
-	public unique(name?: string): ColumnBuilder {
-		return this.with({ unique: name ? { name } : true });
-	}
-
-	public index(name?: string): ColumnBuilder {
-		return this.with({ index: name ? { name } : true });
-	}
-
-	public default(value: unknown): ColumnBuilder {
-		return this.with({ sqlDefault: value });
-	}
-
-	public defaultFn(fn: () => unknown): ColumnBuilder {
-		return this.with({ runtimeDefaultFn: fn });
-	}
-
-	/**
-	 * Shorthand for date columns that should default to the current timestamp.
-	 * Sets SQL `DEFAULT CURRENT_TIMESTAMP` (via `nowDefault`) and
-	 * a runtime default of `new Date()`.
-	 */
-	public defaultNow(): ColumnBuilder {
-		return this.with({
-			nowDefault: true,
-			runtimeDefaultFn: () => new Date(),
-		});
-	}
-
-	public references(
-		table: string,
-		column = "id",
-		actions: Pick<ColumnReference, "onDelete" | "onUpdate"> = {},
-	): ColumnBuilder {
-		return this.with({
-			references: {
-				table,
-				column,
-				onDelete: actions.onDelete,
-				onUpdate: actions.onUpdate,
-			},
-		});
-	}
-
-	public toDefinition(): ColumnDefinition {
-		return { ...this.definition };
-	}
-}
-
-export function table(
-	shape: TableShape,
-	options: TableOptions = {},
-): TableDefinition {
-	const columns: Record<string, ColumnDefinition> = {};
-	const relations: Record<string, RelationDefinition> = {};
-
-	for (const [fieldName, value] of Object.entries(shape)) {
-		if (value instanceof ColumnBuilder) {
-			columns[fieldName] = value.toDefinition();
-			continue;
-		}
-
-		if (value.kind === "relation") {
-			relations[fieldName] = value;
-			continue;
-		}
-
-		throw new Error(
-			`Invalid table field '${fieldName}'. Use column builders or relation helpers.`,
-		);
-	}
-
-	return {
-		kind: "table",
-		sqlName: options.sqlName,
-		columns,
-		relations,
-	};
-}
-
-export function schema(
-	tables: Record<string, TableDefinition>,
-): SchemaDefinition {
-	return {
-		kind: "schema",
-		tables,
-	};
-}
-
-export function isSchemaDefinition(value: unknown): value is SchemaDefinition {
-	if (typeof value !== "object" || value === null) {
-		return false;
-	}
-	const candidate = value as { kind?: string; tables?: unknown };
-	return candidate.kind === "schema" && typeof candidate.tables === "object";
-}
-
-// ---------------------------------------------------------------------------
-// Relation builder helpers
-// ---------------------------------------------------------------------------
-
-function buildOneRelation(
-	targetTable: string,
-	fieldOrOptions?: string | RelationOneOptions,
-	options: RelationOneOptions = {},
-): OneRelationDefinition {
-	const field = typeof fieldOrOptions === "string" ? fieldOrOptions : undefined;
-	const mergedOptions =
-		typeof fieldOrOptions === "string" ? options : (fieldOrOptions ?? options);
-
-	return {
-		kind: "relation",
-		relation: "one",
-		targetTable,
-		field: mergedOptions.field ?? field,
-		referenceField: mergedOptions.referenceField,
-		fkType: mergedOptions.fkType,
-		sqlName: mergedOptions.sqlName,
-		notNull: mergedOptions.notNull,
-		nullable: mergedOptions.nullable,
-		onDelete: mergedOptions.onDelete,
-		onUpdate: mergedOptions.onUpdate,
-	};
-}
-
-function buildManyRelation(
-	targetTable: string,
-	fieldOrOptions?: string | RelationManyOptions,
-	options: RelationManyOptions = {},
-): ManyRelationDefinition {
-	const field = typeof fieldOrOptions === "string" ? fieldOrOptions : undefined;
-	const mergedOptions =
-		typeof fieldOrOptions === "string" ? options : (fieldOrOptions ?? options);
-
-	return {
-		kind: "relation",
-		relation: "many",
-		targetTable,
-		field: mergedOptions.field ?? field,
-		referenceField: mergedOptions.referenceField,
-		fkType: mergedOptions.fkType,
-		sqlName: mergedOptions.sqlName,
-		notNull: mergedOptions.notNull,
-		nullable: mergedOptions.nullable,
-		onDelete: mergedOptions.onDelete,
-		onUpdate: mergedOptions.onUpdate,
-	};
-}
-
-function buildManyToManyRelation(
-	targetTable: string,
-	options: RelationManyToManyOptions = {},
-): ManyToManyRelationDefinition {
-	return {
-		kind: "relation",
-		relation: "manyToMany",
-		targetTable,
-		referenceField: options.referenceField,
-		targetReferenceField: options.targetReferenceField,
-		junctionTable: options.junctionTable,
-		sourceField: options.sourceField,
-		targetField: options.targetField,
-		sourceSqlName: options.sourceSqlName,
-		targetSqlName: options.targetSqlName,
-		onDelete: options.onDelete,
-		onUpdate: options.onUpdate,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export const v = {
-	int: (options: ColumnBuilderOptions = {}) =>
-		new ColumnBuilder("int", options),
-	number: (options: ColumnBuilderOptions = {}) =>
-		new ColumnBuilder("int", options),
-	string: (options: ColumnBuilderOptions = {}) =>
-		new ColumnBuilder("string", options),
-	boolean: (options: ColumnBuilderOptions = {}) =>
-		new ColumnBuilder("boolean", options),
-	date: (options: ColumnBuilderOptions = {}) =>
-		new ColumnBuilder("date", options),
-
-	/**
-	 * UUID primary key column.
-	 * Stored as a string, marked as primary key and auto-populated with
-	 * `crypto.randomUUID()` at runtime (no SQL sequence).
-	 */
-	uuid: (options: ColumnBuilderOptions = {}) =>
-		new ColumnBuilder({
-			kind: "column",
-			type: "string",
-			sqlName: options.sqlName,
-			length: options.length ?? 36,
-			primaryKey: true,
-			notNull: true,
-			nullable: false,
-			uuidPrimaryKey: true,
-			runtimeDefaultFn: () => crypto.randomUUID(),
-		}),
-
-	one: (
-		targetTable: string,
-		fieldOrOptions?: string | RelationOneOptions,
-		options: RelationOneOptions = {},
-	): OneRelationDefinition =>
-		buildOneRelation(targetTable, fieldOrOptions, options),
-
-	many: (
-		targetTable: string,
-		fieldOrOptions?: string | RelationManyOptions,
-		options: RelationManyOptions = {},
-	): ManyRelationDefinition =>
-		buildManyRelation(targetTable, fieldOrOptions, options),
-
-	manyToMany: (
-		targetTable: string,
-		options: RelationManyToManyOptions = {},
-	): ManyToManyRelationDefinition =>
-		buildManyToManyRelation(targetTable, options),
-};
+export type ColumnType = "int" | "string" | "boolean" | "date";
+
+export type ColumnBuilderOptions = {
+	sqlName?: string;
+	length?: number;
+};
+
+export type PrimaryKeyOptions = {
+	autoIncrement?: boolean;
+};
+
+export type ForeignKeyAction =
+	| "cascade"
+	| "set null"
+	| "set default"
+	| "restrict"
+	| "no action";
+
+export type RelationOneOptions = {
+	referenceField?: string;
+	field?: string;
+	fkType?: ColumnType;
+	sqlName?: string;
+	notNull?: boolean;
+	nullable?: boolean;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type RelationManyOptions = {
+	referenceField?: string;
+	field?: string;
+	fkType?: ColumnType;
+	sqlName?: string;
+	notNull?: boolean;
+	nullable?: boolean;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type RelationManyToManyOptions = {
+	referenceField?: string;
+	targetReferenceField?: string;
+	junctionTable?: string;
+	sourceField?: string;
+	targetField?: string;
+	sourceSqlName?: string;
+	targetSqlName?: string;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type ColumnReference = {
+	table: string;
+	column: string;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type ColumnDefinition = {
+	kind: "column";
+	type: ColumnType;
+	sqlName?: string;
+	length?: number;
+	notNull?: boolean;
+	nullable?: boolean;
+	primaryKey?: boolean;
+	autoIncrement?: boolean;
+	/** When true the column stores a UUID generated at runtime (string type). */
+	uuidPrimaryKey?: boolean;
+	unique?: true | { name?: string };
+	index?: true | { name?: string };
+	sqlDefault?: unknown;
+	/** When true, the SQL column gets DEFAULT CURRENT_TIMESTAMP and runtime inserts use `new Date()`. */
+	nowDefault?: boolean;
+	runtimeDefaultFn?: () => unknown;
+	references?: ColumnReference;
+};
+
+export type OneRelationDefinition = {
+	kind: "relation";
+	relation: "one";
+	targetTable: string;
+	field?: string;
+	referenceField?: string;
+	fkType?: ColumnType;
+	sqlName?: string;
+	notNull?: boolean;
+	nullable?: boolean;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type ManyRelationDefinition = {
+	kind: "relation";
+	relation: "many";
+	targetTable: string;
+	field?: string;
+	referenceField?: string;
+	fkType?: ColumnType;
+	sqlName?: string;
+	notNull?: boolean;
+	nullable?: boolean;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type ManyToManyRelationDefinition = {
+	kind: "relation";
+	relation: "manyToMany";
+	targetTable: string;
+	referenceField?: string;
+	targetReferenceField?: string;
+	junctionTable?: string;
+	sourceField?: string;
+	targetField?: string;
+	sourceSqlName?: string;
+	targetSqlName?: string;
+	onDelete?: ForeignKeyAction;
+	onUpdate?: ForeignKeyAction;
+};
+
+export type RelationDefinition =
+	| OneRelationDefinition
+	| ManyRelationDefinition
+	| ManyToManyRelationDefinition;
+
+export type TableOptions = {
+	sqlName?: string;
+};
+
+export type TableShape = Record<string, ColumnBuilder | RelationDefinition>;
+
+export type TableDefinition = {
+	kind: "table";
+	sqlName?: string;
+	columns: Record<string, ColumnDefinition>;
+	relations: Record<string, RelationDefinition>;
+};
+
+export type SchemaDefinition = {
+	kind: "schema";
+	tables: Record<string, TableDefinition>;
+};
+
+export class ColumnBuilder {
+	private definition: ColumnDefinition;
+
+	public constructor(
+		typeOrDefinition: ColumnType | ColumnDefinition,
+		options: ColumnBuilderOptions = {},
+	) {
+		if (typeof typeOrDefinition === "string") {
+			this.definition = {
+				kind: "column",
+				type: typeOrDefinition,
+				sqlName: options.sqlName,
+				length: options.length,
+			};
+			return;
+		}
+
+		this.definition = {
+			...typeOrDefinition,
+		};
+	}
+
+	private with(patch: Partial<ColumnDefinition>): ColumnBuilder {
+		return new ColumnBuilder({
+			...this.definition,
+			...patch,
+		});
+	}
+
+	public sql(name: string): ColumnBuilder {
+		return this.with({ sqlName: name });
+	}
+
+	public notNull(): ColumnBuilder {
+		return this.with({ notNull: true, nullable: false });
+	}
+
+	public nullable(): ColumnBuilder {
+		return this.with({ nullable: true, notNull: false });
+	}
+
+	public primaryKey(options: PrimaryKeyOptions = {}): ColumnBuilder {
+		return this.with({
+			primaryKey: true,
+			autoIncrement: options.autoIncrement ?? this.definition.autoIncrement,
+		});
+	}
+
+	public unique(name?: string): ColumnBuilder {
+		return this.with({ unique: name ? { name } : true });
+	}
+
+	public index(name?: string): ColumnBuilder {
+		return this.with({ index: name ? { name } : true });
+	}
+
+	public default(value: unknown): ColumnBuilder {
+		return this.with({ sqlDefault: value });
+	}
+
+	public defaultFn(fn: () => unknown): ColumnBuilder {
+		return this.with({ runtimeDefaultFn: fn });
+	}
+
+	/**
+	 * Shorthand for date columns that should default to the current timestamp.
+	 * Sets SQL `DEFAULT CURRENT_TIMESTAMP` (via `nowDefault`) and
+	 * a runtime default of `new Date()`.
+	 */
+	public defaultNow(): ColumnBuilder {
+		return this.with({
+			nowDefault: true,
+			runtimeDefaultFn: () => new Date(),
+		});
+	}
+
+	public references(
+		table: string,
+		column = "id",
+		actions: Pick<ColumnReference, "onDelete" | "onUpdate"> = {},
+	): ColumnBuilder {
+		return this.with({
+			references: {
+				table,
+				column,
+				onDelete: actions.onDelete,
+				onUpdate: actions.onUpdate,
+			},
+		});
+	}
+
+	public toDefinition(): ColumnDefinition {
+		return { ...this.definition };
+	}
+}
+
+export function table(
+	shape: TableShape,
+	options: TableOptions = {},
+): TableDefinition {
+	const columns: Record<string, ColumnDefinition> = {};
+	const relations: Record<string, RelationDefinition> = {};
+
+	for (const [fieldName, value] of Object.entries(shape)) {
+		if (value instanceof ColumnBuilder) {
+			columns[fieldName] = value.toDefinition();
+			continue;
+		}
+
+		if (value.kind === "relation") {
+			relations[fieldName] = value;
+			continue;
+		}
+
+		throw new Error(
+			`Invalid table field '${fieldName}'. Use column builders or relation helpers.`,
+		);
+	}
+
+	return {
+		kind: "table",
+		sqlName: options.sqlName,
+		columns,
+		relations,
+	};
+}
+
+export function schema(
+	tables: Record<string, TableDefinition>,
+): SchemaDefinition {
+	return {
+		kind: "schema",
+		tables,
+	};
+}
+
+export function isSchemaDefinition(value: unknown): value is SchemaDefinition {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+	const candidate = value as { kind?: string; tables?: unknown };
+	return candidate.kind === "schema" && typeof candidate.tables === "object";
+}
+
+// ---------------------------------------------------------------------------
+// Relation builder helpers
+// ---------------------------------------------------------------------------
+
+function buildOneRelation(
+	targetTable: string,
+	fieldOrOptions?: string | RelationOneOptions,
+	options: RelationOneOptions = {},
+): OneRelationDefinition {
+	const field = typeof fieldOrOptions === "string" ? fieldOrOptions : undefined;
+	const mergedOptions =
+		typeof fieldOrOptions === "string" ? options : (fieldOrOptions ?? options);
+
+	return {
+		kind: "relation",
+		relation: "one",
+		targetTable,
+		field: mergedOptions.field ?? field,
+		referenceField: mergedOptions.referenceField,
+		fkType: mergedOptions.fkType,
+		sqlName: mergedOptions.sqlName,
+		notNull: mergedOptions.notNull,
+		nullable: mergedOptions.nullable,
+		onDelete: mergedOptions.onDelete,
+		onUpdate: mergedOptions.onUpdate,
+	};
+}
+
+function buildManyRelation(
+	targetTable: string,
+	fieldOrOptions?: string | RelationManyOptions,
+	options: RelationManyOptions = {},
+): ManyRelationDefinition {
+	const field = typeof fieldOrOptions === "string" ? fieldOrOptions : undefined;
+	const mergedOptions =
+		typeof fieldOrOptions === "string" ? options : (fieldOrOptions ?? options);
+
+	return {
+		kind: "relation",
+		relation: "many",
+		targetTable,
+		field: mergedOptions.field ?? field,
+		referenceField: mergedOptions.referenceField,
+		fkType: mergedOptions.fkType,
+		sqlName: mergedOptions.sqlName,
+		notNull: mergedOptions.notNull,
+		nullable: mergedOptions.nullable,
+		onDelete: mergedOptions.onDelete,
+		onUpdate: mergedOptions.onUpdate,
+	};
+}
+
+function buildManyToManyRelation(
+	targetTable: string,
+	options: RelationManyToManyOptions = {},
+): ManyToManyRelationDefinition {
+	return {
+		kind: "relation",
+		relation: "manyToMany",
+		targetTable,
+		referenceField: options.referenceField,
+		targetReferenceField: options.targetReferenceField,
+		junctionTable: options.junctionTable,
+		sourceField: options.sourceField,
+		targetField: options.targetField,
+		sourceSqlName: options.sourceSqlName,
+		targetSqlName: options.targetSqlName,
+		onDelete: options.onDelete,
+		onUpdate: options.onUpdate,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export const v = {
+	int: (options: ColumnBuilderOptions = {}) =>
+		new ColumnBuilder("int", options),
+	number: (options: ColumnBuilderOptions = {}) =>
+		new ColumnBuilder("int", options),
+	string: (options: ColumnBuilderOptions = {}) =>
+		new ColumnBuilder("string", options),
+	boolean: (options: ColumnBuilderOptions = {}) =>
+		new ColumnBuilder("boolean", options),
+	date: (options: ColumnBuilderOptions = {}) =>
+		new ColumnBuilder("date", options),
+
+	/**
+	 * UUID primary key column.
+	 * Stored as a string, marked as primary key and auto-populated with
+	 * `crypto.randomUUID()` at runtime (no SQL sequence).
+	 */
+	uuid: (options: ColumnBuilderOptions = {}) =>
+		new ColumnBuilder({
+			kind: "column",
+			type: "string",
+			sqlName: options.sqlName,
+			length: options.length ?? 36,
+			primaryKey: true,
+			notNull: true,
+			nullable: false,
+			uuidPrimaryKey: true,
+			runtimeDefaultFn: () => crypto.randomUUID(),
+		}),
+
+	one: (
+		targetTable: string,
+		fieldOrOptions?: string | RelationOneOptions,
+		options: RelationOneOptions = {},
+	): OneRelationDefinition =>
+		buildOneRelation(targetTable, fieldOrOptions, options),
+
+	many: (
+		targetTable: string,
+		fieldOrOptions?: string | RelationManyOptions,
+		options: RelationManyOptions = {},
+	): ManyRelationDefinition =>
+		buildManyRelation(targetTable, fieldOrOptions, options),
+
+	manyToMany: (
+		targetTable: string,
+		options: RelationManyToManyOptions = {},
+	): ManyToManyRelationDefinition =>
+		buildManyToManyRelation(targetTable, options),
+};