@studiocms/migrator 0.0.0-beta.0 → 0.1.0

package/src/db/astrodb.ts

@@ -0,0 +1,88 @@
+import { type AstroDBTableKeys, astroDbTableKeys } from '../lib/tableMap';
+import { db, sql } from './astro-db-drizzle-client.js';
+
+export const runConnectionTest = async () => {
+	try {
+		await db.$client.execute('SELECT CURRENT_TIME');
+		return true;
+	} catch (_error) {
+		return false;
+	}
+};
+
+/**
+ * Search for tables in a LibSQL database by name using Drizzle
+ * @param searchPattern - Search pattern (supports wildcards: %)
+ * @returns Array of matching table names
+ */
+export async function searchTables(searchPattern: string): Promise<string[]> {
+	const result = await db.all<{ name: string }>(
+		sql`
+      SELECT name 
+      FROM sqlite_master 
+      WHERE type = 'table' 
+        AND name LIKE ${searchPattern}
+        AND name NOT LIKE 'sqlite_%'
+        AND name != '_astro_db_snapshot'
+      ORDER BY name
+    `
+	);
+
+	return result.map((row) => row.name);
+}
+
+/**
+ * Get all tables in the database
+ * @returns Array of all table names
+ */
+export async function getAllTables(): Promise<string[]> {
+	return searchTables('%');
+}
+
+/**
+ * Check if a specific table exists
+ * @param tableName - Exact table name to check
+ * @returns Boolean indicating if table exists
+ */
+export async function tableExists(tableName: string): Promise<boolean> {
+	const tables = await searchTables(tableName);
+	return tables.length > 0;
+}
+
+export const getTableLength = async (table: AstroDBTableKeys) => {
+	const result = await db.get<{ count: number }>(
+		sql`SELECT COUNT(*) as count FROM ${sql.raw(table)}`
+	);
+
+	return result?.count ?? 0;
+};
+
+export const getDataMigrationMeta = async () => {
+	const tableLengths: Record<AstroDBTableKeys, number> = {} as Record<AstroDBTableKeys, number>;
+
+	for (const table of astroDbTableKeys) {
+		const result = await getTableLength(table).catch(() => 0);
+		tableLengths[table] = result;
+	}
+
+	return tableLengths;
+};
+
+// Usage examples:
+// async function examples() {
+// 	// Search for tables starting with "user"
+// 	const userTables = await searchTables('user%');
+// 	console.log('Tables starting with "user":', userTables);
+
+// 	// Search for tables containing "post"
+// 	const postTables = await searchTables('%post%');
+// 	console.log('Tables containing "post":', postTables);
+
+// 	// Get all tables
+// 	const allTables = await getAllTables();
+// 	console.log('All tables:', allTables);
+
+// 	// Check if specific table exists
+// 	const exists = await tableExists('users');
+// 	console.log('Table "users" exists:', exists);
+// }

package/src/db/client.ts

@@ -0,0 +1,156 @@
+import { runEffect } from '@withstudiocms/effect';
+import { getDBClientLive } from '@withstudiocms/kysely/client';
+import { sql } from '@withstudiocms/kysely/kysely';
+import { getMigratorLive } from '@withstudiocms/sdk/migrator';
+import type { StudioCMSDatabaseSchema } from '@withstudiocms/sdk/tables';
+import { type KyselyTableKeys, kyselyTableKeys } from '../lib/tableMap';
+
+/**
+ * Dynamically import and return the database driver based on the provided dialect.
+ *
+ * @param dialect - The database dialect as a string.
+ * @returns The database driver.
+ * @throws Error if the dialect is unsupported.
+ */
+async function getDialectDriver(dialect: string | undefined) {
+	switch (dialect) {
+		case 'libsql': {
+			const mod = await import('@withstudiocms/kysely/drivers/libsql');
+			return await runEffect(mod.libsqlDriver);
+		}
+		case 'postgres': {
+			const mod = await import('@withstudiocms/kysely/drivers/postgres');
+			return await runEffect(mod.postgresDriver);
+		}
+		case 'mysql': {
+			const mod = await import('@withstudiocms/kysely/drivers/mysql');
+			return await runEffect(mod.mysqlDriver);
+		}
+		default:
+			throw new Error(`Unsupported STUDIOCMS_DIALECT: ${dialect}`);
+	}
+}
+
+/**
+ * Get a StudioCMS database client based on the STUDIOCMS_DIALECT environment variable.
+ *
+ * @returns The StudioCMS database client.
+ * @throws Error if the STUDIOCMS_DIALECT environment variable is not set or unsupported.
+ */
+export const getStudioCMSDb = async () => {
+	const dialect = process.env.STUDIOCMS_DIALECT;
+	if (!dialect) {
+		throw new Error('STUDIOCMS_DIALECT environment variable is not set.');
+	}
+
+	const driver = await getDialectDriver(dialect);
+	return await runEffect(getDBClientLive<StudioCMSDatabaseSchema>(driver));
+};
+
+/**
+ * Get a StudioCMS database migrator based on the STUDIOCMS_DIALECT environment variable.
+ *
+ * @returns The StudioCMS database migrator.
+ * @throws Error if the STUDIOCMS_DIALECT environment variable is not set or unsupported.
+ */
+export const studioCMSDbMigrator = async () => {
+	const dialect = process.env.STUDIOCMS_DIALECT;
+	if (!dialect) {
+		throw new Error('STUDIOCMS_DIALECT environment variable is not set.');
+	}
+
+	const driver = await getDialectDriver(dialect);
+	return await runEffect(getMigratorLive(driver));
+};
+
+/**
+ * Run a connection test to the StudioCMS database.
+ *
+ * @returns Boolean indicating if the connection test was successful.
+ */
+export const runConnectionTest = async () => {
+	const { db } = await getStudioCMSDb();
+	try {
+		await db.executeQuery(sql`SELECT CURRENT_TIME;`.compile(db));
+		return true;
+	} catch (_e) {
+		return false;
+	}
+};
+
+/**
+ * Map of supported database dialects to their display names.
+ */
+const dialectMap = {
+	libsql: 'LibSQL',
+	mysql: 'MySQL',
+	postgres: 'PostgreSQL',
+};
+
+/**
+ * Get the database dialect from the environment variable.
+ *
+ * @returns The display name of the database dialect.
+ */
+export const getDialectFromEnv = () => {
+	return dialectMap[process.env.STUDIOCMS_DIALECT as keyof typeof dialectMap] || 'Unknown';
+};
+
+/**
+ * Get the number of rows in a specified table.
+ *
+ * @param table - The name of the table.
+ * @returns The number of rows in the table.
+ */
+export const getTableLength = async (table: KyselyTableKeys) => {
+	const { db } = await getStudioCMSDb();
+	const result = await db.selectFrom(table).select(sql`COUNT(*)`.as('count')).executeTakeFirst();
+
+	if (!result) {
+		return 0;
+	}
+
+	return Number(result.count);
+};
+
+/**
+ * Check the data migration status by verifying if any tables contain rows.
+ *
+ * @returns An object indicating whether migration can proceed.
+ */
+export const getDataMigrationStatus = async () => {
+	const tablesWithRows: string[] = [];
+
+	for (const table of kyselyTableKeys) {
+		const result = await getTableLength(table).catch(() => 0);
+		if (result > 0) {
+			tablesWithRows.push(table);
+		}
+	}
+
+	if (tablesWithRows.length > 0) {
+		return {
+			canMigrate: false,
+		};
+	}
+
+	return {
+		canMigrate: true,
+	};
+};
+
+/**
+ * Get metadata about the data migration, including the number of rows in each table.
+ *
+ * @returns An object mapping table names to their respective row counts.
+ */
+export const getDataMigrationMeta = async () => {
+	const tableLengths: Record<KyselyTableKeys, number> = {} as Record<KyselyTableKeys, number>;
+
+	for (const table of kyselyTableKeys) {
+		const result = await getTableLength(table).catch(() => 0);
+		tableLengths[table] = result;
+	}
+
+	return tableLengths;
+};

package/src/db/drizzle-schema.ts

@@ -0,0 +1,54 @@
+import { asDrizzleTable } from '../lib/astro-db-drizzle-compat/index.js';
+import * as Schema from './astro-db-schema.js';
+
+export const StudioCMSUsers = asDrizzleTable('StudioCMSUsers', Schema.StudioCMSUsers);
+export const StudioCMSPageData = asDrizzleTable('StudioCMSPageData', Schema.StudioCMSPageData);
+export const StudioCMSPageFolderStructure = asDrizzleTable(
+	'StudioCMSPageFolderStructure',
+	Schema.StudioCMSPageFolderStructure
+);
+export const StudioCMSPageDataTags = asDrizzleTable(
+	'StudioCMSPageDataTags',
+	Schema.StudioCMSPageDataTags
+);
+export const StudioCMSPageDataCategories = asDrizzleTable(
+	'StudioCMSPageDataCategories',
+	Schema.StudioCMSPageDataCategories
+);
+export const StudioCMSPluginData = asDrizzleTable(
+	'StudioCMSPluginData',
+	Schema.StudioCMSPluginData
+);
+export const StudioCMSDynamicConfigSettings = asDrizzleTable(
+	'StudioCMSDynamicConfigSettings',
+	Schema.StudioCMSDynamicConfigSettings
+);
+export const StudioCMSAPIKeys = asDrizzleTable('StudioCMSAPIKeys', Schema.StudioCMSAPIKeys);
+export const StudioCMSUserResetTokens = asDrizzleTable(
+	'StudioCMSUserResetTokens',
+	Schema.StudioCMSUserResetTokens
+);
+export const StudioCMSOAuthAccounts = asDrizzleTable(
+	'StudioCMSOAuthAccounts',
+	Schema.StudioCMSOAuthAccounts
+);
+export const StudioCMSSessionTable = asDrizzleTable(
+	'StudioCMSSessionTable',
+	Schema.StudioCMSSessionTable
+);
+export const StudioCMSPermissions = asDrizzleTable(
+	'StudioCMSPermissions',
+	Schema.StudioCMSPermissions
+);
+export const StudioCMSDiffTracking = asDrizzleTable(
+	'StudioCMSDiffTracking',
+	Schema.StudioCMSDiffTracking
+);
+export const StudioCMSPageContent = asDrizzleTable(
+	'StudioCMSPageContent',
+	Schema.StudioCMSPageContent
+);
+export const StudioCMSEmailVerificationTokens = asDrizzleTable(
+	'StudioCMSEmailVerificationTokens',
+	Schema.StudioCMSEmailVerificationTokens
+);

package/src/env.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="../.astro/types.d.ts" />
+/// <reference types="astro/client" />
+/// <reference types="@studiocms/ui/v/types" />

package/src/fonts/css/onest-variable.css

@@ -0,0 +1,16 @@
+/* Onest Variable Font from Fontsource */
+@font-face {
+	font-family: "Onest Variable";
+	font-style: normal;
+	font-display: swap;
+	font-weight: 100 900;
+	src: url("../woff2/onest-variable.woff2") format("woff2-variations");
+	unicode-range:
+		U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+/* CSS variable with Onest Variable font and system font fallback */
+:root {
+	--scms-font-onest:
+		"Onest Variable", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+}

package/src/layouts/Layout.astro

@@ -0,0 +1,30 @@
+---
+import { Toaster } from 'studiocms:ui/components/toaster';
+import PageHeader from '../components/PageHeader.astro';
+import '../fonts/css/onest-variable.css';
+import '../styles/global.css';
+import 'studiocms:ui/prose';
+
+interface Props {
+	title: string;
+}
+
+const { title } = Astro.props;
+---
+
+<html lang="en">
+    <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width" />
+        <meta name="generator" content={Astro.generator} />
+        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+        <title>{title}</title>
+    </head>
+    <body>
+        <Toaster />
+        <main>
+            <PageHeader />
+            <slot />
+        </main>
+    </body>
+</html>

package/src/lib/astro-db-drizzle-compat/core-types.ts

@@ -0,0 +1,88 @@
+import type { z } from 'astro/zod';
+import type {
+	booleanColumnSchema,
+	columnSchema,
+	columnsSchema,
+	dateColumnSchema,
+	dbConfigSchema,
+	indexSchema,
+	jsonColumnSchema,
+	MaybeArray,
+	numberColumnOptsSchema,
+	numberColumnSchema,
+	referenceableColumnSchema,
+	resolvedIndexSchema,
+	tableSchema,
+	textColumnOptsSchema,
+	textColumnSchema,
+} from './schemas.js';
+
+export type ResolvedIndexes = z.output<typeof dbConfigSchema>['tables'][string]['indexes'];
+export type BooleanColumn = z.infer<typeof booleanColumnSchema>;
+export type BooleanColumnInput = z.input<typeof booleanColumnSchema>;
+export type NumberColumn = z.infer<typeof numberColumnSchema>;
+export type NumberColumnInput = z.input<typeof numberColumnSchema>;
+export type TextColumn = z.infer<typeof textColumnSchema>;
+export type TextColumnInput = z.input<typeof textColumnSchema>;
+export type DateColumn = z.infer<typeof dateColumnSchema>;
+export type DateColumnInput = z.input<typeof dateColumnSchema>;
+export type JsonColumn = z.infer<typeof jsonColumnSchema>;
+export type JsonColumnInput = z.input<typeof jsonColumnSchema>;
+
+export type ColumnType =
+	| BooleanColumn['type']
+	| NumberColumn['type']
+	| TextColumn['type']
+	| DateColumn['type']
+	| JsonColumn['type'];
+
+export type DBColumn = z.infer<typeof columnSchema>;
+export type DBColumnInput =
+	| DateColumnInput
+	| BooleanColumnInput
+	| NumberColumnInput
+	| TextColumnInput
+	| JsonColumnInput;
+export type DBColumns = z.infer<typeof columnsSchema>;
+export type DBTable = z.infer<typeof tableSchema>;
+export type DBTables = Record<string, DBTable>;
+export type ResolvedDBTables = z.output<typeof dbConfigSchema>['tables'];
+export type ResolvedDBTable = z.output<typeof dbConfigSchema>['tables'][string];
+export type DBSnapshot = {
+	schema: Record<string, ResolvedDBTable>;
+	version: string;
+};
+
+export type DBConfigInput = z.input<typeof dbConfigSchema>;
+export type DBConfig = z.infer<typeof dbConfigSchema>;
+
+export type ColumnsConfig = z.input<typeof tableSchema>['columns'];
+export type OutputColumnsConfig = z.output<typeof tableSchema>['columns'];
+
+export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig>
+	// use `extends` to ensure types line up with zod,
+	// only adding generics for type completions.
+	extends Pick<z.input<typeof tableSchema>, 'columns' | 'indexes' | 'foreignKeys'> {
+	columns: TColumns;
+	foreignKeys?: Array<{
+		columns: MaybeArray<Extract<keyof TColumns, string>>;
+		references: () => MaybeArray<z.input<typeof referenceableColumnSchema>>;
+	}>;
+	indexes?: Array<IndexConfig<TColumns>> | Record<string, LegacyIndexConfig<TColumns>>;
+	deprecated?: boolean;
+}
+
+interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
+	on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+
+/** @deprecated */
+interface LegacyIndexConfig<TColumns extends ColumnsConfig>
+	extends z.input<typeof resolvedIndexSchema> {
+	on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+
+// We cannot use `Omit<NumberColumn | TextColumn, 'type'>`,
+// since Omit collapses our union type on primary key.
+export type NumberColumnOpts = z.input<typeof numberColumnOptsSchema>;
+export type TextColumnOpts = z.input<typeof textColumnOptsSchema>;

package/src/lib/astro-db-drizzle-compat/error-map.ts

@@ -0,0 +1,105 @@
+/**
+ * This is a modified version of Astro's error map. source:
+ * https://github.com/withastro/astro/blob/main/packages/astro/src/content/error-map.ts
+ */
+/** biome-ignore-all lint/suspicious/noExplicitAny: source code from `@astrojs/db` */
+import type { z } from 'astro/zod';
+
+interface TypeOrLiteralErrByPathEntry {
+	code: 'invalid_type' | 'invalid_literal';
+	received: unknown;
+	expected: unknown[];
+}
+
+export const errorMap: z.ZodErrorMap = (baseError, ctx) => {
+	const baseErrorPath = flattenErrorPath(baseError.path);
+	if (baseError.code === 'invalid_union') {
+		// Optimization: Combine type and literal errors for keys that are common across ALL union types
+		// Ex. a union between `{ key: z.literal('tutorial') }` and `{ key: z.literal('blog') }` will
+		// raise a single error when `key` does not match:
+		// > Did not match union.
+		// > key: Expected `'tutorial' | 'blog'`, received 'foo'
+		const typeOrLiteralErrByPath = new Map<string, TypeOrLiteralErrByPathEntry>();
+		for (const unionError of baseError.unionErrors.flatMap((e) => e.errors)) {
+			if (unionError.code === 'invalid_type' || unionError.code === 'invalid_literal') {
+				const flattenedErrorPath = flattenErrorPath(unionError.path);
+				const typeOrLiteralErr = typeOrLiteralErrByPath.get(flattenedErrorPath);
+				if (typeOrLiteralErr) {
+					typeOrLiteralErr.expected.push(unionError.expected);
+				} else {
+					typeOrLiteralErrByPath.set(flattenedErrorPath, {
+						code: unionError.code,
+						received: (unionError as any).received,
+						expected: [unionError.expected],
+					});
+				}
+			}
+		}
+		const messages: string[] = [
+			prefix(
+				baseErrorPath,
+				typeOrLiteralErrByPath.size ? 'Did not match union:' : 'Did not match union.'
+			),
+		];
+		return {
+			message: messages
+				.concat(
+					[...typeOrLiteralErrByPath.entries()]
+						// If type or literal error isn't common to ALL union types,
+						// filter it out. Can lead to confusing noise.
+						.filter(([, error]) => error.expected.length === baseError.unionErrors.length)
+						.map(([key, error]) =>
+							// Avoid printing the key again if it's a base error
+							key === baseErrorPath
+								? `> ${getTypeOrLiteralMsg(error)}`
+								: `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+						)
+				)
+				.join('\n'),
+		};
+	}
+	if (baseError.code === 'invalid_literal' || baseError.code === 'invalid_type') {
+		return {
+			message: prefix(
+				baseErrorPath,
+				getTypeOrLiteralMsg({
+					code: baseError.code,
+					received: (baseError as any).received,
+					expected: [baseError.expected],
+				})
+			),
+		};
+	}
+	if (baseError.message) {
+		return { message: prefix(baseErrorPath, baseError.message) };
+	}
+	return { message: prefix(baseErrorPath, ctx.defaultError) };
+};
+
+const getTypeOrLiteralMsg = (error: TypeOrLiteralErrByPathEntry): string => {
+	if (error.received === 'undefined') return 'Required';
+	const expectedDeduped = new Set(error.expected);
+	switch (error.code) {
+		case 'invalid_type':
+			return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+				error.received
+			)}`;
+		case 'invalid_literal':
+			return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+				error.received
+			)}`;
+	}
+};
+
+const prefix = (key: string, msg: string) => (key.length ? `**${key}**: ${msg}` : msg);
+
+const unionExpectedVals = (expectedVals: Set<unknown>) =>
+	[...expectedVals]
+		.map((expectedVal, idx) => {
+			if (idx === 0) return JSON.stringify(expectedVal);
+			const sep = ' | ';
+			return `${sep}${JSON.stringify(expectedVal)}`;
+		})
+		.join('');
+
+const flattenErrorPath = (errorPath: Array<string | number>) => errorPath.join('.');

package/src/lib/astro-db-drizzle-compat/index.ts

@@ -0,0 +1,149 @@
+import { type ColumnBuilderBaseConfig, type ColumnDataType, sql } from 'drizzle-orm';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import {
+	customType,
+	type IndexBuilder,
+	index,
+	integer,
+	type SQLiteColumnBuilderBase,
+	sqliteTable,
+	text,
+} from 'drizzle-orm/sqlite-core';
+import type { ColumnsConfig, DBColumn, DBTable, TableConfig } from './core-types.js';
+import { tableSchema } from './schemas.js';
+import { isSerializedSQL, type SerializedSQL, type Table } from './types.js';
+import { hasPrimaryKey } from './utils.js';
+export type Database = LibSQLDatabase;
+export type { Table } from './types.js';
+export { hasPrimaryKey } from './utils.js';
+
+// Taken from:
+// https://stackoverflow.com/questions/52869695/check-if-a-date-string-is-in-iso-and-utc-format
+const isISODateString = (str: string) => /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(str);
+
+const dateType = customType<{ data: Date; driverData: string }>({
+	dataType() {
+		return 'text';
+	},
+	toDriver(value) {
+		return value.toISOString();
+	},
+	fromDriver(value) {
+		if (!isISODateString(value)) {
+			// values saved using CURRENT_TIMESTAMP are not valid ISO strings
+			// but *are* in UTC, so append the UTC zone.
+			value += 'Z';
+		}
+		return new Date(value);
+	},
+});
+
+const jsonType = customType<{ data: unknown; driverData: string }>({
+	dataType() {
+		return 'text';
+	},
+	toDriver(value) {
+		return JSON.stringify(value);
+	},
+	fromDriver(value) {
+		return JSON.parse(value);
+	},
+});
+
+type D1ColumnBuilder = SQLiteColumnBuilderBase<
+	ColumnBuilderBaseConfig<ColumnDataType, string> & { data: unknown }
+>;
+
+export function internal_asDrizzleTable(name: string, table: DBTable) {
+	const columns: Record<string, D1ColumnBuilder> = {};
+	if (!Object.entries(table.columns).some(([, column]) => hasPrimaryKey(column))) {
+		columns._id = integer('_id').primaryKey();
+	}
+	for (const [columnName, column] of Object.entries(table.columns)) {
+		columns[columnName] = columnMapper(columnName, column);
+	}
+	const drizzleTable = sqliteTable(name, columns, (ormTable) => {
+		const indexes: Array<IndexBuilder> = [];
+		for (const [indexName, indexProps] of Object.entries(table.indexes ?? {})) {
+			const onColNames = Array.isArray(indexProps.on) ? indexProps.on : [indexProps.on];
+			const onCols = onColNames.map((colName) => ormTable[colName]);
+			if (!atLeastOne(onCols)) continue;
+
+			indexes.push(index(indexName).on(...onCols));
+		}
+		return indexes;
+	});
+	return drizzleTable;
+}
+
+export function asDrizzleTable<
+	TableName extends string = string,
+	TColumns extends ColumnsConfig = ColumnsConfig,
+>(name: TableName, tableConfig: TableConfig<TColumns>) {
+	return internal_asDrizzleTable(name, tableSchema.parse(tableConfig)) as Table<
+		TableName,
+		TColumns
+	>;
+}
+
+function atLeastOne<T>(arr: T[]): arr is [T, ...T[]] {
+	return arr.length > 0;
+}
+
+function columnMapper(columnName: string, column: DBColumn) {
+	let c: ReturnType<
+		| typeof text
+		| typeof integer
+		| typeof jsonType
+		| typeof dateType
+		| typeof integer<string, 'boolean'>
+	>;
+
+	switch (column.type) {
+		case 'text': {
+			c = text(columnName, { enum: column.schema.enum });
+			// Duplicate default logic across cases to preserve type inference.
+			// No clean generic for every column builder.
+			if (column.schema.default !== undefined)
+				c = c.default(handleSerializedSQL(column.schema.default));
+			if (column.schema.primaryKey === true) c = c.primaryKey();
+			break;
+		}
+		case 'number': {
+			c = integer(columnName);
+			if (column.schema.default !== undefined)
+				c = c.default(handleSerializedSQL(column.schema.default));
+			if (column.schema.primaryKey === true) c = c.primaryKey();
+			break;
+		}
+		case 'boolean': {
+			c = integer(columnName, { mode: 'boolean' });
+			if (column.schema.default !== undefined)
+				c = c.default(handleSerializedSQL(column.schema.default));
+			break;
+		}
+		case 'json':
+			c = jsonType(columnName);
+			if (column.schema.default !== undefined) c = c.default(column.schema.default);
+			break;
+		case 'date': {
+			c = dateType(columnName);
+			if (column.schema.default !== undefined) {
+				const def = handleSerializedSQL(column.schema.default);
+				c = c.default(typeof def === 'string' ? new Date(def) : def);
+			}
+			break;
+		}
+	}
+
+	if (!column.schema.optional) c = c.notNull();
+	if (column.schema.unique) c = c.unique();
+	return c;
+}
+
+function handleSerializedSQL<T>(def: T | SerializedSQL) {
+	if (isSerializedSQL(def)) {
+		return sql.raw(def.sql);
+	}
+	return def;
+}