appflare 0.2.35 → 0.2.37

package/Documentation.md

@@ -398,14 +398,14 @@ bun run build
 
 What gets generated (core set):
 
-- `_generated/server.ts`
-- `_generated/client.ts`
-- `_generated/auth.config.ts`
-- `_generated/drizzle.config.ts`
-- `_generated/handlers.ts`
-- `_generated/handlers.context.ts`
-- `_generated/handlers.execution.ts`
-- `_generated/handlers.routes.ts`
+- `_generated/server.js`
+- `_generated/client.js`
+- `_generated/auth.config.js`
+- `_generated/drizzle.config.js`
+- `_generated/handlers.js`
+- `_generated/handlers.context.js`
+- `_generated/handlers.execution.js`
+- `_generated/handlers.routes.js`
 - `_generated/client/**`
 
 ### Watch mode

package/cli/commands/index.ts

@@ -121,7 +121,7 @@ export async function runMigrate(
 
 	const drizzleConfigPath = resolve(
 		loadedConfig.outDirAbs,
-		"drizzle.config.ts",
+		"drizzle.config.js",
 	);
 	const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
 	const drizzleGenerate = Bun.spawn(

package/cli/generate.ts

@@ -15,6 +15,27 @@ import { discoverHandlerOperations } from "./utils/handler-discovery";
 import { discoverSchema } from "./utils/schema-discovery";
 import { ensureRelativeImportPath } from "./utils/path-utils";
 
+function extractRolesFromConfig(config: LoadedAppflareConfig["config"]): string[] {
+	const plugins = (config.auth.options as Record<string, unknown>).plugins;
+	if (!Array.isArray(plugins)) return [];
+
+	for (const plugin of plugins) {
+		if (plugin && typeof plugin === "object") {
+			const pluginObj = plugin as Record<string, unknown>;
+			if (pluginObj.id === "admin" && "options" in pluginObj) {
+				const options = (pluginObj as Record<string, unknown>).options as Record<string, unknown> | undefined;
+				if (options && typeof options === "object" && "roles" in options) {
+					const rolesObj = options.roles as Record<string, unknown>;
+					if (rolesObj && typeof rolesObj === "object") {
+						return Object.keys(rolesObj);
+					}
+				}
+			}
+		}
+	}
+	return [];
+}
+
 function toConfigRelativePath(configDir: string, absolutePath: string): string {
 	const relativePath = relative(configDir, absolutePath).replace(/\\/g, "/");
 	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
@@ -74,6 +95,8 @@ export async function generateArtifacts(
 		`🔍 ${discoveredHandlers.length} handler(s) (${(performance.now() - t0).toFixed(0)}ms)\n`,
 	);
 
+	const roles = extractRolesFromConfig(config);
+
 	const serverSource = generateServerSource(
 		config.auth.basePath,
 		config.database[0].binding,
@@ -94,6 +117,7 @@ export async function generateArtifacts(
 		schemaImport,
 		discoveredHandlers,
 		config.r2[0]?.binding,
+		roles,
 	);
 	const authConfigSource = generateAuthConfigSource(configImport);
 	const drizzleSchemaPaths = compiledSchema

package/cli/index.ts

@@ -13,7 +13,7 @@ program
 program
 	.command("build")
 	.description(
-		"Generate server.ts, client.ts, auth.config.ts, drizzle.config.ts, and wrangler.json artifacts",
+		"Generate server.ts, client.ts, auth.config.js, drizzle.config.js, and wrangler.json artifacts",
 	)
 	.option(
 		"-c, --config <path>",

package/cli/schema-compiler.ts

@@ -4,6 +4,7 @@ import { pathToFileURL } from "node:url";
 import type {
 	ColumnDefinition,
 	ColumnType,
+	JsonShape,
 	ManyRelationDefinition,
 	ManyToManyRelationDefinition,
 	OneRelationDefinition,
@@ -96,6 +97,11 @@ function cloneSchemaDefinition(definition: SchemaDefinition): SchemaDefinition {
 				];
 			}),
 		),
+		enums: Object.fromEntries(
+			Object.entries(definition.enums ?? {}).map(([name, enumDef]) => {
+				return [name, { ...enumDef }];
+			}),
+		),
 	};
 }
 
@@ -658,6 +664,23 @@ function drizzleBaseColumn(
 		return 't.int({ mode: "timestamp_ms" })';
 	}
 
+	if (column.type === "enum" && column.enumValues && column.enumValues.length > 0) {
+		if (column.isArray) {
+			return needsExplicitName
+				? `t.text(${quote(resolvedSqlName)}).array()`
+				: "t.text().array()";
+		}
+		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
+	}
+
+	if (column.type === "json" && column.jsonShape) {
+		const tsType = jsonShapeToTypeScript(column.jsonShape);
+		const base = needsExplicitName
+			? `t.text(${quote(resolvedSqlName)}, { mode: "json" })`
+			: `t.text({ mode: "json" })`;
+		return `${base}.$type<${tsType}>()`;
+	}
+
 	if (strategy === "camelToSnake") {
 		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
 	}
@@ -730,6 +753,53 @@ function resolveColumnReference(
 	};
 }
 
+function emitJsonColumnsMetadata(definition: SchemaDefinition): string {
+	const tableEntries: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const columnEntries: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			if (column.type !== "json" || !column.jsonShape) continue;
+
+			const shapeStr = jsonShapeToRuntimeLiteral(column.jsonShape);
+			columnEntries.push(
+				`${quote(fieldName)}: { shape: ${shapeStr} },`,
+			);
+		}
+
+		if (columnEntries.length === 0) continue;
+
+		tableEntries.push(
+			`${quote(tableName)}: {
+${columnEntries.map((entry) => `\t\t${entry}`).join("\n")}
+	},`,
+		);
+	}
+
+	if (tableEntries.length === 0) {
+		return "export const __appflareJsonColumns = {} as const;\n";
+	}
+
+	return `export const __appflareJsonColumns = {
+${tableEntries.map((entry) => `\t${entry}`).join("\n")}
+} as const;
+`;
+}
+
+function jsonShapeToRuntimeLiteral(shape: JsonShape): string {
+	if (shape.kind === "array") {
+		return `{ kind: "array", element: ${jsonShapeToRuntimeLiteral(shape.element)} }`;
+	}
+	if (shape.kind === "object") {
+		const fields = Object.entries(shape.shape)
+			.map(([key, fieldShape]) => `${quote(key)}: ${jsonShapeToRuntimeLiteral(fieldShape)}`)
+			.join(", ");
+		return `{ kind: "object", shape: { ${fields} } }`;
+	}
+	return `{ kind: ${quote(shape.kind)} }`;
+}
+
 function emitManyToManyRuntimeMetadata(definition: SchemaDefinition): string {
 	const tableEntries: string[] = [];
 
@@ -861,6 +931,33 @@ function emitDrizzleSchema(
 		}
 	}
 
+	const enumColumns = new Map<string, ColumnDefinition>();
+	for (const table of Object.values(definition.tables)) {
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			if (
+				column.type === "enum" &&
+				column.enumValues &&
+				column.enumValues.length > 0
+			) {
+				const key = column.enumRef ?? `${fieldName}`;
+				if (!enumColumns.has(key)) {
+					enumColumns.set(key, column);
+				}
+			}
+		}
+	}
+
+	const enumTypeLines: string[] = [];
+	const enumCustomTypeLines: string[] = [];
+	for (const [key, column] of enumColumns.entries()) {
+		const typeName = toPascalCase(key);
+		const valuesStr = column.enumValues!.map((v) => `"${v}"`).join(" | ");
+		enumTypeLines.push(`export type ${typeName} = ${valuesStr};`);
+		enumCustomTypeLines.push(
+			`export const ${typeName}Column = t.customType<{ data: ${typeName}; dataNotNull: ${typeName} }>({ dataType: () => "text" });`,
+		);
+	}
+
 	const tableBlocks: string[] = [];
 	const relationBlocks: string[] = [];
 
@@ -870,7 +967,25 @@ function emitDrizzleSchema(
 		const indexes: string[] = [];
 
 		for (const [fieldName, column] of Object.entries(table.columns)) {
-			let expr = drizzleBaseColumn(fieldName, column, strategy);
+			let expr: string;
+			if (
+				column.type === "enum" &&
+				column.enumValues &&
+				column.enumValues.length > 0
+			) {
+				const enumKey = column.enumRef ?? fieldName;
+				const typeName = toPascalCase(enumKey);
+				const resolvedSqlName = column.sqlName ?? toSnakeCase(fieldName);
+				const needsExplicitName = resolvedSqlName !== fieldName;
+				expr = needsExplicitName
+					? `${typeName}Column(${quote(resolvedSqlName)})`
+					: `${typeName}Column()`;
+				if (column.isArray) {
+					expr += ".array()";
+				}
+			} else {
+				expr = drizzleBaseColumn(fieldName, column, strategy);
+			}
 
 			if (column.uuidPrimaryKey) {
 				expr += ".$defaultFn(() => crypto.randomUUID())";
@@ -987,16 +1102,38 @@ function emitDrizzleSchema(
 import { sqliteTable as table } from "drizzle-orm/sqlite-core";
 import { relations } from "drizzle-orm";
 ${buildExternalTableImportLines(externalTables)}
+${enumTypeLines.join("\n")}
+${enumCustomTypeLines.join("\n")}
+
 ${tableBlocks.join("\n\n")}
 
 ${relationBlocks.join("\n\n")}
 
+${emitJsonColumnsMetadata(definition)}
+
 ${emitManyToManyRuntimeMetadata(definition)}
 
 ${emitRuntimeRelationMetadata(definition)}
 `;
 }
 
+function jsonShapeToZod(shape: JsonShape): string {
+	if (shape.kind === "array") {
+		return `z.array(${jsonShapeToZod(shape.element)})`;
+	}
+	if (shape.kind === "object") {
+		const fields = Object.entries(shape.shape)
+			.map(([key, fieldShape]) => `${quote(key)}: ${jsonShapeToZod(fieldShape)}`)
+			.join(", ");
+		return `z.object({ ${fields} })`;
+	}
+	if (shape.kind === "string") return "z.string()";
+	if (shape.kind === "number") return "z.number()";
+	if (shape.kind === "boolean") return "z.boolean()";
+	if (shape.kind === "date") return "z.date()";
+	return "z.unknown()";
+}
+
 function zodSchemaExpression(
 	column: ColumnDefinition,
 	optional: boolean,
@@ -1014,6 +1151,12 @@ function zodSchemaExpression(
 		expr = "z.boolean()";
 	} else if (column.type === "date") {
 		expr = "z.date()";
+	} else if (column.type === "enum" && column.enumValues && column.enumValues.length > 0) {
+		const valuesStr = column.enumValues.map((v) => `"${v}"`).join(", ");
+		const enumZod = `z.enum([${valuesStr}])`;
+		expr = column.isArray ? `z.array(${enumZod})` : enumZod;
+	} else if (column.type === "json" && column.jsonShape) {
+		expr = jsonShapeToZod(column.jsonShape);
 	}
 
 	if (optional) {
@@ -1057,6 +1200,23 @@ export type ${pascal}Select = z.infer<typeof ${tableName}SelectSchema>;
 ${blocks.join("\n")}`;
 }
 
+function jsonShapeToTypeScript(shape: JsonShape): string {
+	if (shape.kind === "array") {
+		return `Array<${jsonShapeToTypeScript(shape.element)}>`;
+	}
+	if (shape.kind === "object") {
+		const fields = Object.entries(shape.shape)
+			.map(([key, fieldShape]) => `${key}: ${jsonShapeToTypeScript(fieldShape)}`)
+			.join("; ");
+		return `{ ${fields} }`;
+	}
+	if (shape.kind === "string") return "string";
+	if (shape.kind === "number") return "number";
+	if (shape.kind === "boolean") return "boolean";
+	if (shape.kind === "date") return "Date";
+	return "unknown";
+}
+
 function toTypeScriptType(column: ColumnDefinition): string {
 	if (column.type === "int") {
 		return "number";
@@ -1070,10 +1230,27 @@ function toTypeScriptType(column: ColumnDefinition): string {
 	if (column.type === "date") {
 		return "Date";
 	}
+	if (column.type === "enum" && column.enumValues && column.enumValues.length > 0) {
+		const union = column.enumValues.map((v) => `"${v}"`).join(" | ");
+		if (column.isArray) {
+			return `Array<${union}>`;
+		}
+		return union;
+	}
+	if (column.type === "json" && column.jsonShape) {
+		return jsonShapeToTypeScript(column.jsonShape);
+	}
 	return "unknown";
 }
 
 function emitTypes(definition: SchemaDefinition): string {
+	const enumTypeLines: string[] = [];
+	for (const [name, enumDef] of Object.entries(definition.enums ?? {})) {
+		const typeName = toPascalCase(name);
+		const valuesStr = enumDef.values.map((v) => `"${v}"`).join(" | ");
+		enumTypeLines.push(`export type ${typeName} = ${valuesStr};`);
+	}
+
 	const lines: string[] = [];
 
 	for (const [tableName, table] of Object.entries(definition.tables)) {
@@ -1097,7 +1274,8 @@ function emitTypes(definition: SchemaDefinition): string {
 export type New${pascal} = {\n${insertFields.join("\n")}\n};`);
 	}
 
-	return `${lines.join("\n\n")}
+	return `${enumTypeLines.join("\n")}
+${lines.join("\n\n")}
 `;
 }
 

package/cli/templates/core/README.md

@@ -12,7 +12,7 @@ The core template modules are responsible for generating:
 
 1. **Worker server source** (`src/index.ts` style output)
 2. **Cloudflare Wrangler config** (`wrangler.json` shape)
-3. **Drizzle config source** (`drizzle.config.ts`)
+3. **Drizzle config source** (`drizzle.config.js`)
 4. **Typed Appflare client source** (Better Auth client wrapper)
 5. **Generated handlers integration** (registering auto-generated route handlers)
 

package/cli/templates/core/client/handlers/index.ts

@@ -111,6 +111,13 @@ function normalizeOperation(
 					.filter(Boolean)
 					.slice(1);
 
+	if (
+		segments.length >= 2 &&
+		segments[segments.length - 1] === segments[segments.length - 2]
+	) {
+		segments.pop();
+	}
+
 	if (segments.length === 0) {
 		return null;
 	}

package/cli/templates/handlers/generators/handlers.ts

@@ -1,6 +1,6 @@
 import { generateTypes } from "../types";
 
-export function generateHandlersSource(schemaImportPath: string): string {
+export function generateHandlersSource(schemaImportPath: string, roles: string[] = []): string {
 	return `import type { Context } from "hono";
 import type { D1Database } from "@cloudflare/workers-types";
 import { drizzle } from "drizzle-orm/d1";
@@ -8,6 +8,6 @@ import { z, type ZodRawShape } from "zod";
 import * as authSchema from "./auth.schema";
 import * as schema from "${schemaImportPath}";
 
-${generateTypes()}
+${generateTypes(roles)}
 `;
 }

package/cli/templates/handlers/generators/registration/modules/realtime/utils.ts

@@ -188,26 +188,20 @@ function compareOrderValues(
 function hasKnownOperator(condition: Record<string, unknown>): boolean {
 	return [
 		"eq",
-		"$eq",
 		"ne",
-		"$ne",
 		"in",
-		"$in",
 		"nin",
-		"$nin",
 		"gt",
-		"$gt",
 		"gte",
-		"$gte",
 		"lt",
-		"$lt",
 		"lte",
-		"$lte",
 		"exists",
 		"regex",
-		"$options",
+		"options",
 		"geoWithin",
-		"$geoWithin",
+		"includes",
+		"includesAny",
+		"length",
 	].some((key) => key in condition);
 }
 

package/cli/templates/handlers/generators/types/context.ts

@@ -1,7 +1,13 @@
-export function generateTypesContextSection(): string {
+export function generateTypesContextSection(roles: string[] = []): string {
+	const userTypeExtension =
+		roles.length > 0
+			? `type UserRole = ${roles.map((r) => `"${r}"`).join(" | ")};
+type User = Omit<AuthSession['user'], 'role'> & { role: UserRole };`
+			: `type User = AuthSession['user']`;
+
 	return `type AuthSession = typeof auth.$Infer.Session;
 type AuthAdapter = Awaited<typeof auth.$context>["internalAdapter"];
-type User = AuthSession['user']
+${userTypeExtension}
 type Session = AuthSession['session']
 
 export type StoragePutArgs = {

package/cli/templates/handlers/generators/types/query-definitions/filter-and-where-types.ts

@@ -19,16 +19,12 @@ type GeoWithinOperand = {
 	$geometry: GeoPoint | GeoCoordinates;
 	latitudeField?: string;
 	longitudeField?: string;
-	$minDistance?: number;
-	$maxDistance?: number;
+	minDistance?: number;
+	maxDistance?: number;
 	gt?: number;
 	gte?: number;
 	lt?: number;
 	lte?: number;
-	$gt?: number;
-	$gte?: number;
-	$lt?: number;
-	$lte?: number;
 };
 
 type GeoWithinOperandForField<TFieldKey extends string> = Omit<
@@ -41,25 +37,20 @@ type GeoWithinOperandForField<TFieldKey extends string> = Omit<
 
 type FieldOperators<T, TFieldKey extends string = string> = {
 	eq?: Friendly<NonNil<T>>;
-	$eq?: Friendly<NonNil<T>>;
 	ne?: Friendly<NonNil<T>>;
-	$ne?: Friendly<NonNil<T>>;
 	in?: ReadonlyArray<Friendly<NonNil<T>>>;
-	$in?: ReadonlyArray<Friendly<NonNil<T>>>;
 	nin?: ReadonlyArray<Friendly<NonNil<T>>>;
-	$nin?: ReadonlyArray<Friendly<NonNil<T>>>;
 	gt?: Comparable<T>;
-	$gt?: Comparable<T>;
 	gte?: Comparable<T>;
-	$gte?: Comparable<T>;
 	lt?: Comparable<T>;
-	$lt?: Comparable<T>;
 	lte?: Comparable<T>;
-	$lte?: Comparable<T>;
 	exists?: boolean;
 	regex?: RegexOperand<T>;
-	$options?: string;
+	options?: string;
 	geoWithin?: GeoWithinOperandForField<TFieldKey>;
+	includes?: T extends ReadonlyArray<infer E> ? ReadonlyArray<E> : never;
+	includesAny?: T extends ReadonlyArray<infer E> ? ReadonlyArray<E> : never;
+	length?: T extends ReadonlyArray<unknown> ? number : never;
 };
 
 type WhereFieldValue<T, TFieldKey extends string> =
@@ -72,7 +63,6 @@ type RelationWhereInput<TModel extends Record<string, unknown>, TName extends Ta
 		| (TModel[K] extends Record<string, unknown> ? RelationWhereInput<TModel[K]> : never);
 } & {
 	geoWithin?: GeoWithinOperandForField<Extract<keyof TModel, string>>;
-	$geoWithin?: GeoWithinOperandForField<Extract<keyof TModel, string>>;
 } & (TName extends TableName ? {
 	[TRelation in keyof NativeFindManyWith<TName>]?: NativeFindManyWith<TName>[TRelation] extends infer TRelationConfig
 		? TRelationConfig extends Record<string, unknown>