appflare 0.2.14 → 0.2.15

package/cli/schema-compiler.ts

@@ -121,6 +121,8 @@ function ensureInferredReferenceColumn(
 		fkType?: ColumnType;
 		sqlName?: string;
 		notNull?: boolean;
+		onDelete?: OneRelationDefinition["onDelete"];
+		onUpdate?: OneRelationDefinition["onUpdate"];
 	},
 	inferredType: ColumnType,
 ): void {
@@ -138,7 +140,17 @@ function ensureInferredReferenceColumn(
 
 		table.columns[columnName] = {
 			...existing,
-			references: { table: referenceTable, column: referenceField },
+			notNull:
+				existing.notNull ??
+				(existing.nullable === true ? false : options.notNull),
+			nullable:
+				existing.nullable ?? (options.notNull === false ? true : undefined),
+			references: {
+				table: referenceTable,
+				column: referenceField,
+				onDelete: existing.references?.onDelete ?? options.onDelete,
+				onUpdate: existing.references?.onUpdate ?? options.onUpdate,
+			},
 		};
 		return;
 	}
@@ -148,16 +160,66 @@ function ensureInferredReferenceColumn(
 		type: options.fkType ?? inferredType,
 		sqlName: options.sqlName,
 		notNull: options.notNull ?? true,
+		nullable: options.notNull === false ? true : undefined,
 		references: {
 			table: referenceTable,
 			column: referenceField,
+			onDelete: options.onDelete,
+			onUpdate: options.onUpdate,
 		},
 	};
 }
 
+function resolveNotNullFromNullableFlags(
+	fieldPath: string,
+	flags: { notNull?: boolean; nullable?: boolean },
+	defaultNotNull: boolean,
+): boolean {
+	if (flags.notNull === true && flags.nullable === true) {
+		throw new Error(
+			`Invalid nullable configuration on '${fieldPath}': cannot set both notNull and nullable to true.`,
+		);
+	}
+
+	if (flags.notNull === true) {
+		return true;
+	}
+
+	if (flags.nullable === true) {
+		return false;
+	}
+
+	if (flags.notNull === false) {
+		return false;
+	}
+
+	return defaultNotNull;
+}
+
+function validateNullableFlags(definition: SchemaDefinition): void {
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		for (const [columnName, column] of Object.entries(table.columns)) {
+			if (column.notNull === true && column.nullable === true) {
+				throw new Error(
+					`Invalid nullable configuration on '${tableName}.${columnName}': cannot set both notNull and nullable to true.`,
+				);
+			}
+		}
+
+		for (const [relationName, relation] of Object.entries(table.relations)) {
+			if (relation.notNull === true && relation.nullable === true) {
+				throw new Error(
+					`Invalid nullable configuration on '${tableName}.${relationName}': cannot set both notNull and nullable to true.`,
+				);
+			}
+		}
+	}
+}
+
 function normalizeSchemaDefinition(
 	definition: SchemaDefinition,
 ): SchemaDefinition {
+	validateNullableFlags(definition);
 	const normalized = cloneSchemaDefinition(definition);
 
 	for (const [tableName, table] of Object.entries(normalized.tables)) {
@@ -188,7 +250,13 @@ function normalizeSchemaDefinition(
 				{
 					fkType: relation.fkType,
 					sqlName: relation.sqlName,
-					notNull: relation.notNull,
+					notNull: resolveNotNullFromNullableFlags(
+						`${tableName}.${relationName}`,
+						relation,
+						true,
+					),
+					onDelete: relation.onDelete,
+					onUpdate: relation.onUpdate,
 				},
 				inferredType,
 			);
@@ -225,7 +293,13 @@ function normalizeSchemaDefinition(
 				{
 					fkType: relation.fkType,
 					sqlName: relation.sqlName,
-					notNull: relation.notNull,
+					notNull: resolveNotNullFromNullableFlags(
+						`${sourceTableName}.${relation.targetTable}`,
+						relation,
+						true,
+					),
+					onDelete: relation.onDelete,
+					onUpdate: relation.onUpdate,
 				},
 				inferredType,
 			);
@@ -237,6 +311,7 @@ function normalizeSchemaDefinition(
 
 function isOptionalInsertColumn(column: ColumnDefinition): boolean {
 	return (
+		column.primaryKey === true ||
 		column.notNull !== true ||
 		column.autoIncrement === true ||
 		column.sqlDefault !== undefined ||
@@ -388,6 +463,10 @@ function emitDrizzleSchema(
 		for (const [fieldName, column] of Object.entries(table.columns)) {
 			let expr = drizzleBaseColumn(fieldName, column, strategy);
 
+			if (column.uuidPrimaryKey) {
+				expr += ".$defaultFn(() => crypto.randomUUID())";
+			}
+
 			if (column.primaryKey) {
 				expr += column.autoIncrement
 					? ".primaryKey({ autoIncrement: true })"
@@ -402,7 +481,18 @@ function emitDrizzleSchema(
 
 			const reference = resolveColumnReference(fieldName, column, table);
 			if (reference) {
-				expr += `.references(() => ${reference.tableName}.${reference.fieldName})`;
+				if (column.references?.onDelete || column.references?.onUpdate) {
+					const actions: string[] = [];
+					if (column.references.onDelete) {
+						actions.push(`onDelete: ${quote(column.references.onDelete)}`);
+					}
+					if (column.references.onUpdate) {
+						actions.push(`onUpdate: ${quote(column.references.onUpdate)}`);
+					}
+					expr += `.references(() => ${reference.tableName}.${reference.fieldName}, { ${actions.join(", ")} })`;
+				} else {
+					expr += `.references(() => ${reference.tableName}.${reference.fieldName})`;
+				}
 			}
 
 			if (column.unique) {
@@ -480,6 +570,7 @@ ${relationBlocks.join("\n\n")}
 function zodSchemaExpression(
 	column: ColumnDefinition,
 	optional: boolean,
+	nullable: boolean,
 ): string {
 	let expr = "z.unknown()";
 	if (column.type === "int") {
@@ -499,6 +590,10 @@ function zodSchemaExpression(
 		expr += ".optional()";
 	}
 
+	if (nullable) {
+		expr += ".nullable()";
+	}
+
 	return expr;
 }
 
@@ -512,10 +607,10 @@ function emitZodSchemas(definition: SchemaDefinition): string {
 
 		for (const [fieldName, column] of Object.entries(table.columns)) {
 			insertLines.push(
-				`\t${fieldName}: ${zodSchemaExpression(column, isOptionalInsertColumn(column))},`,
+				`\t${fieldName}: ${zodSchemaExpression(column, isOptionalInsertColumn(column), isNullableSelectColumn(column))},`,
 			);
 			selectLines.push(
-				`\t${fieldName}: ${zodSchemaExpression(column, isNullableSelectColumn(column))},`,
+				`\t${fieldName}: ${zodSchemaExpression(column, isNullableSelectColumn(column), isNullableSelectColumn(column))},`,
 			);
 		}
 
@@ -558,11 +653,12 @@ function emitTypes(definition: SchemaDefinition): string {
 
 		for (const [fieldName, column] of Object.entries(table.columns)) {
 			const tsType = toTypeScriptType(column);
+			const nullableSuffix = isNullableSelectColumn(column) ? " | null" : "";
 			selectFields.push(
-				`\t${fieldName}${isNullableSelectColumn(column) ? "?" : ""}: ${tsType};`,
+				`\t${fieldName}${isNullableSelectColumn(column) ? "?" : ""}: ${tsType}${nullableSuffix};`,
 			);
 			insertFields.push(
-				`\t${fieldName}${isOptionalInsertColumn(column) ? "?" : ""}: ${tsType};`,
+				`\t${fieldName}${isOptionalInsertColumn(column) ? "?" : ""}: ${tsType}${nullableSuffix};`,
 			);
 		}
 

package/cli/templates/dashboard/builders/table-routes/helpers.ts

@@ -8,10 +8,6 @@ export function resolvePrimaryKey(table: DiscoveredTable): string {
 	);
 }
 
-function hasColumnDefault(expression: string): boolean {
-	return /\.default\s*\(/i.test(expression);
-}
-
 export function shouldIncludeCreateField(
 	table: DiscoveredTable,
 	columnName: string,
@@ -25,7 +21,7 @@ export function shouldIncludeCreateField(
 		return false;
 	}
 
-	if (column.primaryKey && hasColumnDefault(column.expression)) {
+	if (column.primaryKey) {
 		return false;
 	}
 

package/cli/templates/handlers/generators/types/query-definitions/schema-and-table-types.ts

@@ -38,20 +38,25 @@ type ResolveTableFindManySelection<
 			(ResolveNativeFindManyWith<TName, TArgs> extends never
 				? {}
 				: { with: ResolveNativeFindManyWith<TName, TArgs> });
+type TableModel<TName extends TableName> = InferSelectModel<
+	(typeof mergedSchema)[TName]
+>;
 type TableFindManyResult<
 	TName extends TableName,
 	TArgs extends QueryFindManyArgs<TName> | undefined =
 		| QueryFindManyArgs<TName>
 		| undefined,
-> = Promise<
-	Array<
-		BuildQueryResult<
-			SchemaRelations,
-			TableRelationConfig<TName>,
-			ResolveTableFindManySelection<TName, TArgs>
-		>
-	>
->;
+> = TArgs extends undefined
+	? Promise<Array<TableModel<TName>>>
+	: Promise<
+			Array<
+				BuildQueryResult<
+					SchemaRelations,
+					TableRelationConfig<TName>,
+					ResolveTableFindManySelection<TName, TArgs>
+				>
+			>
+	  >;
 type TableFindFirstArgs<TName extends TableName> = Omit<
 	TableFindManyArgs<TName>,
 	"limit"
@@ -80,16 +85,15 @@ type TableFindFirstResult<
 	TArgs extends QueryFindFirstArgs<TName> | undefined =
 		| QueryFindFirstArgs<TName>
 		| undefined,
-> = Promise<
-	BuildQueryResult<
-		SchemaRelations,
-		TableRelationConfig<TName>,
-		ResolveTableFindFirstSelection<TName, TArgs>
-	> | null
->;
-type TableModel<TName extends TableName> = InferSelectModel<
-	(typeof mergedSchema)[TName]
->;
+> = TArgs extends undefined
+	? Promise<TableModel<TName> | null>
+	: Promise<
+			BuildQueryResult<
+				SchemaRelations,
+				TableRelationConfig<TName>,
+				ResolveTableFindFirstSelection<TName, TArgs>
+			> | null
+	  >;
 type TableInsertModel<TName extends TableName> = InferInsertModel<
 	(typeof mergedSchema)[TName]
 >;

package/cli/utils/schema-discovery.ts

@@ -235,7 +235,7 @@ function discoverColumns(rawColumns: string): DiscoveredColumn[] {
 		const autoIncrement = /autoincrement\s*:\s*true/i.test(expression);
 		const hasDefault = /\.default\s*\(/i.test(expression);
 		const notNull = /\.notnull\s*\(/i.test(expression);
-		const optional = !notNull || hasDefault || autoIncrement;
+		const optional = !notNull || hasDefault || autoIncrement || primaryKey;
 
 		columns.push({
 			name: key,