@studiocms/migrator 0.0.0-beta.0 → 0.1.0

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

@@ -0,0 +1,249 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: source from `@astrojs/db` */
+/** biome-ignore-all lint/correctness/noUnusedVariables: source from `@astrojs/db` */
+import { type ZodTypeDef, z } from 'astro/zod';
+import { SQL } from 'drizzle-orm';
+import { SQLiteAsyncDialect } from 'drizzle-orm/sqlite-core';
+import type { NumberColumn, TextColumn } from './core-types.js';
+import { errorMap } from './error-map.js';
+import { SERIALIZED_SQL_KEY, type SerializedSQL } from './types.js';
+import { mapObject } from './utils.js';
+
+export type MaybeArray<T> = T | T[];
+
+// Transform to serializable object for migration files
+const sqlite = new SQLiteAsyncDialect();
+
+const sqlSchema = z.instanceof(SQL<any>).transform(
+	(sqlObj): SerializedSQL => ({
+		[SERIALIZED_SQL_KEY]: true,
+		sql: sqlite.sqlToQuery(sqlObj).sql,
+	})
+);
+
+const baseColumnSchema = z.object({
+	label: z.string().optional(),
+	optional: z.boolean().optional().default(false),
+	unique: z.boolean().optional().default(false),
+	deprecated: z.boolean().optional().default(false),
+
+	// Defined when `defineDb()` is called to resolve `references`
+	name: z.string().optional(),
+	collection: z.string().optional(),
+});
+
+export const booleanColumnSchema = z.object({
+	type: z.literal('boolean'),
+	schema: baseColumnSchema.extend({
+		default: z.union([z.boolean(), sqlSchema]).optional(),
+	}),
+});
+
+const numberColumnBaseSchema = baseColumnSchema.omit({ optional: true }).and(
+	z.union([
+		z.object({
+			primaryKey: z.literal(false).optional().default(false),
+			optional: baseColumnSchema.shape.optional,
+			default: z.union([z.number(), sqlSchema]).optional(),
+		}),
+		z.object({
+			// `integer primary key` uses ROWID as the default value.
+			// `optional` and `default` do not have an effect,
+			// so disable these config options for primary keys.
+			primaryKey: z.literal(true),
+			optional: z.literal(false).optional(),
+			default: z.literal(undefined).optional(),
+		}),
+	])
+);
+
+export const numberColumnOptsSchema: z.ZodType<
+	z.infer<typeof numberColumnBaseSchema> & {
+		// ReferenceableColumn creates a circular type. Define ZodType to resolve.
+		references?: NumberColumn;
+	},
+	ZodTypeDef,
+	z.input<typeof numberColumnBaseSchema> & {
+		references?: () => z.input<typeof numberColumnSchema>;
+	}
+> = numberColumnBaseSchema.and(
+	z.object({
+		references: z
+			.function()
+			.returns(z.lazy(() => numberColumnSchema))
+			.optional()
+			.transform((fn) => fn?.()),
+	})
+);
+
+export const numberColumnSchema = z.object({
+	type: z.literal('number'),
+	schema: numberColumnOptsSchema,
+});
+
+const textColumnBaseSchema = baseColumnSchema
+	.omit({ optional: true })
+	.extend({
+		default: z.union([z.string(), sqlSchema]).optional(),
+		multiline: z.boolean().optional(),
+		enum: z.tuple([z.string()]).rest(z.string()).optional(), // At least one value required,
+	})
+	.and(
+		z.union([
+			z.object({
+				primaryKey: z.literal(false).optional().default(false),
+				optional: baseColumnSchema.shape.optional,
+			}),
+			z.object({
+				// text primary key allows NULL values.
+				// NULL values bypass unique checks, which could
+				// lead to duplicate URLs per record.
+				// disable `optional` for primary keys.
+				primaryKey: z.literal(true),
+				optional: z.literal(false).optional(),
+			}),
+		])
+	);
+
+export const textColumnOptsSchema: z.ZodType<
+	z.infer<typeof textColumnBaseSchema> & {
+		// ReferenceableColumn creates a circular type. Define ZodType to resolve.
+		references?: TextColumn;
+	},
+	ZodTypeDef,
+	z.input<typeof textColumnBaseSchema> & {
+		references?: () => z.input<typeof textColumnSchema>;
+	}
+> = textColumnBaseSchema.and(
+	z.object({
+		references: z
+			.function()
+			.returns(z.lazy(() => textColumnSchema))
+			.optional()
+			.transform((fn) => fn?.()),
+	})
+);
+
+export const textColumnSchema = z.object({
+	type: z.literal('text'),
+	schema: textColumnOptsSchema,
+});
+
+export const dateColumnSchema = z.object({
+	type: z.literal('date'),
+	schema: baseColumnSchema.extend({
+		default: z
+			.union([
+				sqlSchema,
+				// transform to ISO string for serialization
+				z
+					.date()
+					.transform((d) => d.toISOString()),
+			])
+			.optional(),
+	}),
+});
+
+export const jsonColumnSchema = z.object({
+	type: z.literal('json'),
+	schema: baseColumnSchema.extend({
+		default: z.unknown().optional(),
+	}),
+});
+
+export const columnSchema = z.discriminatedUnion('type', [
+	booleanColumnSchema,
+	numberColumnSchema,
+	textColumnSchema,
+	dateColumnSchema,
+	jsonColumnSchema,
+]);
+export const referenceableColumnSchema = z.union([textColumnSchema, numberColumnSchema]);
+
+export const columnsSchema = z.record(columnSchema);
+
+type ForeignKeysInput = {
+	columns: MaybeArray<string>;
+	references: () => MaybeArray<Omit<z.input<typeof referenceableColumnSchema>, 'references'>>;
+};
+
+type ForeignKeysOutput = Omit<ForeignKeysInput, 'references'> & {
+	// reference fn called in `transform`. Ensures output is JSON serializable.
+	references: MaybeArray<Omit<z.output<typeof referenceableColumnSchema>, 'references'>>;
+};
+
+const foreignKeysSchema: z.ZodType<ForeignKeysOutput, ZodTypeDef, ForeignKeysInput> = z.object({
+	columns: z.string().or(z.array(z.string())),
+	references: z
+		.function()
+		.returns(z.lazy(() => referenceableColumnSchema.or(z.array(referenceableColumnSchema))))
+		.transform((fn) => fn()),
+});
+
+export const resolvedIndexSchema = z.object({
+	on: z.string().or(z.array(z.string())),
+	unique: z.boolean().optional(),
+});
+/** @deprecated */
+const legacyIndexesSchema = z.record(resolvedIndexSchema);
+
+export const indexSchema = z.object({
+	on: z.string().or(z.array(z.string())),
+	unique: z.boolean().optional(),
+	name: z.string().optional(),
+});
+const indexesSchema = z.array(indexSchema);
+
+export const tableSchema = z.object({
+	columns: columnsSchema,
+	indexes: indexesSchema.or(legacyIndexesSchema).optional(),
+	foreignKeys: z.array(foreignKeysSchema).optional(),
+	deprecated: z.boolean().optional().default(false),
+});
+
+export const tablesSchema = z.preprocess((rawTables) => {
+	// Use `z.any()` to avoid breaking object references
+	const tables = z.record(z.any()).parse(rawTables, { errorMap });
+	for (const [tableName, table] of Object.entries(tables)) {
+		// Append table and column names to columns.
+		// Used to track table info for references.
+		table.getName = () => tableName;
+		const { columns } = z.object({ columns: z.record(z.any()) }).parse(table, { errorMap });
+		for (const [columnName, column] of Object.entries(columns)) {
+			column.schema.name = columnName;
+			column.schema.collection = tableName;
+		}
+	}
+	return rawTables;
+}, z.record(tableSchema));
+
+export const dbConfigSchema = z
+	.object({
+		tables: tablesSchema.optional(),
+	})
+	.transform(({ tables = {}, ...config }) => {
+		return {
+			...config,
+			tables: mapObject(tables, (tableName, table) => {
+				const { indexes = {} } = table;
+				if (!Array.isArray(indexes)) {
+					return { ...table, indexes };
+				}
+				const resolvedIndexes: Record<string, z.infer<typeof resolvedIndexSchema>> = {};
+				for (const index of indexes) {
+					if (index.name) {
+						const { name, ...rest } = index;
+						resolvedIndexes[index.name] = rest;
+						continue;
+					}
+					// Sort index columns to ensure consistent index names
+					const indexOn = Array.isArray(index.on) ? index.on.sort().join('_') : index.on;
+					const name = `${tableName}_${indexOn}_idx`;
+					resolvedIndexes[name] = index;
+				}
+				return {
+					...table,
+					indexes: resolvedIndexes,
+				};
+			}),
+		};
+	});

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

@@ -0,0 +1,141 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: source from `@astrojs/db` */
+import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
+import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { ColumnsConfig, DBColumn, OutputColumnsConfig } from './core-types.js';
+
+type GeneratedConfig<T extends ColumnDataType = ColumnDataType> = Pick<
+	ColumnBaseConfig<T, string>,
+	'name' | 'tableName' | 'notNull' | 'hasDefault' | 'hasRuntimeDefault' | 'isPrimaryKey'
+>;
+
+type AstroText<
+	T extends GeneratedConfig<'string'>,
+	E extends readonly [string, ...string[]] | string,
+> = SQLiteColumn<
+	T & {
+		data: E extends readonly (infer U)[] ? U : string;
+		dataType: 'string';
+		columnType: 'SQLiteText';
+		driverParam: string;
+		enumValues: E extends [string, ...string[]] ? E : never;
+		baseColumn: never;
+		isAutoincrement: boolean;
+		identity: undefined;
+		generated: undefined;
+	}
+>;
+
+type AstroDate<T extends GeneratedConfig<'custom'>> = SQLiteColumn<
+	T & {
+		data: Date;
+		dataType: 'custom';
+		columnType: 'SQLiteCustomColumn';
+		driverParam: string;
+		enumValues: never;
+		baseColumn: never;
+		isAutoincrement: boolean;
+		identity: undefined;
+		generated: undefined;
+	}
+>;
+
+type AstroBoolean<T extends GeneratedConfig<'boolean'>> = SQLiteColumn<
+	T & {
+		data: boolean;
+		dataType: 'boolean';
+		columnType: 'SQLiteBoolean';
+		driverParam: number;
+		enumValues: never;
+		baseColumn: never;
+		isAutoincrement: boolean;
+		identity: undefined;
+		generated: undefined;
+	}
+>;
+
+type AstroNumber<T extends GeneratedConfig<'number'>> = SQLiteColumn<
+	T & {
+		data: number;
+		dataType: 'number';
+		columnType: 'SQLiteInteger';
+		driverParam: number;
+		enumValues: never;
+		baseColumn: never;
+		isAutoincrement: boolean;
+		identity: undefined;
+		generated: undefined;
+	}
+>;
+
+type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<
+	T & {
+		data: unknown;
+		dataType: 'custom';
+		columnType: 'SQLiteCustomColumn';
+		driverParam: string;
+		enumValues: never;
+		baseColumn: never;
+		isAutoincrement: boolean;
+		identity: undefined;
+		generated: undefined;
+	}
+>;
+
+type Column<
+	T extends DBColumn['type'],
+	E extends readonly [string, ...string[]] | string,
+	S extends GeneratedConfig,
+> = T extends 'boolean'
+	? AstroBoolean<S>
+	: T extends 'number'
+		? AstroNumber<S>
+		: T extends 'text'
+			? AstroText<S, E>
+			: T extends 'date'
+				? AstroDate<S>
+				: T extends 'json'
+					? AstroJson<S>
+					: never;
+
+export type Table<
+	TTableName extends string,
+	TColumns extends OutputColumnsConfig | ColumnsConfig,
+> = SQLiteTableWithColumns<{
+	name: TTableName;
+	schema: undefined;
+	dialect: 'sqlite';
+	columns: {
+		[K in Extract<keyof TColumns, string>]: Column<
+			TColumns[K]['type'],
+			TColumns[K]['schema'] extends { enum: infer E }
+				? E extends readonly [string, ...string[]]
+					? E
+					: string
+				: string,
+			{
+				tableName: TTableName;
+				name: K;
+				isPrimaryKey: TColumns[K]['schema'] extends { primaryKey: true } ? true : false;
+				hasDefault: TColumns[K]['schema'] extends { default: NonNullable<unknown> }
+					? true
+					: TColumns[K]['schema'] extends { primaryKey: true }
+						? true
+						: false;
+				hasRuntimeDefault: TColumns[K]['schema'] extends { default: NonNullable<unknown> }
+					? true
+					: false;
+				notNull: TColumns[K]['schema']['optional'] extends true ? false : true;
+			}
+		>;
+	};
+}>;
+
+export const SERIALIZED_SQL_KEY = '__serializedSQL';
+export type SerializedSQL = {
+	[SERIALIZED_SQL_KEY]: true;
+	sql: string;
+};
+
+export function isSerializedSQL(value: any): value is SerializedSQL {
+	return typeof value === 'object' && value !== null && SERIALIZED_SQL_KEY in value;
+}

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

@@ -0,0 +1,55 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: source from `@astrojs/db` */
+import { LibsqlError } from '@libsql/client';
+import { AstroError } from 'astro/errors';
+import type { DBColumn } from './core-types.js';
+
+export function hasPrimaryKey(column: DBColumn) {
+	return 'primaryKey' in column.schema && !!column.schema.primaryKey;
+}
+
+const isWindows = process?.platform === 'win32';
+
+export class AstroDbError extends AstroError {
+	name = 'Astro DB Error';
+}
+
+export function isDbError(err: unknown): err is LibsqlError {
+	return err instanceof LibsqlError || (err instanceof Error && (err as any).libsqlError === true);
+}
+
+function slash(path: string) {
+	const isExtendedLengthPath = path.startsWith('\\\\?\\');
+
+	if (isExtendedLengthPath) {
+		return path;
+	}
+
+	return path.replace(/\\/g, '/');
+}
+
+export function pathToFileURL(path: string): URL {
+	if (isWindows) {
+		let slashed = slash(path);
+		// Windows like C:/foo/bar
+		if (!slashed.startsWith('/')) {
+			slashed = `/${slashed}`;
+		}
+		return new URL(`file://${slashed}`);
+	}
+
+	// Unix is easy
+	return new URL(`file://${path}`);
+}
+
+/**
+ * Map an object's values to a new set of values
+ * while preserving types.
+ */
+export function mapObject<T, U = T>(
+	item: Record<string, T>,
+	callback: (key: string, value: T) => U
+): Record<string, U> {
+	return Object.fromEntries(
+		Object.entries(item).map(([key, value]) => [key, callback(key, value)])
+	);
+}

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

@@ -0,0 +1,91 @@
+import { sql as _sql } from 'drizzle-orm';
+import type {
+	BooleanColumnInput,
+	ColumnsConfig,
+	DateColumnInput,
+	JsonColumnInput,
+	NumberColumnOpts,
+	TableConfig,
+	TextColumnOpts,
+} from './core-types.js';
+
+function createColumn<S extends string, T extends Record<string, unknown>>(type: S, schema: T) {
+	return {
+		type,
+		/**
+		 * @internal
+		 */
+		schema,
+	};
+}
+
+export const column = {
+	number: <T extends NumberColumnOpts>(opts: T = {} as T) => {
+		return createColumn('number', opts) satisfies { type: 'number' };
+	},
+	boolean: <T extends BooleanColumnInput['schema']>(opts: T = {} as T) => {
+		return createColumn('boolean', opts) satisfies { type: 'boolean' };
+	},
+	text: <
+		T extends TextColumnOpts,
+		const E extends T['enum'] extends readonly [string, ...string[]]
+			? Omit<T, 'enum'> & T['enum']
+			: T,
+	>(
+		opts: E = {} as E
+	) => {
+		return createColumn('text', opts) satisfies { type: 'text' };
+	},
+	date<T extends DateColumnInput['schema']>(opts: T = {} as T) {
+		return createColumn('date', opts) satisfies { type: 'date' };
+	},
+	json<T extends JsonColumnInput['schema']>(opts: T = {} as T) {
+		return createColumn('json', opts) satisfies { type: 'json' };
+	},
+};
+
+export function defineTable<TColumns extends ColumnsConfig>(userConfig: TableConfig<TColumns>) {
+	return userConfig;
+}
+
+// Exports a few common expressions
+export const NOW = _sql`CURRENT_TIMESTAMP`;
+export const TRUE = _sql`TRUE`;
+export const FALSE = _sql`FALSE`;
+
+export {
+	and,
+	asc,
+	avg,
+	avgDistinct,
+	between,
+	count,
+	countDistinct,
+	desc,
+	eq,
+	exists,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	isNotNull,
+	isNull,
+	like,
+	lt,
+	lte,
+	max,
+	min,
+	ne,
+	not,
+	notBetween,
+	notExists,
+	notIlike,
+	notInArray,
+	or,
+	sql,
+	sum,
+	sumDistinct,
+} from 'drizzle-orm';
+
+export { alias } from 'drizzle-orm/sqlite-core';
+export { isDbError } from './utils.js';

package/src/lib/errors.ts

@@ -0,0 +1,57 @@
+/**
+ * Error case for missing required AstroDB tables in the connected database.
+ */
+export const AstroDbTableError = {
+	title: 'Error: Missing Required AstroDB Tables',
+	description:
+		'It seems that not all required StudioCMS AstroDB tables were found in your connected database. Please ensure that you have connected to the correct database that contains your previous StudioCMS data.',
+};
+
+/**
+ * Error case for pending schema migrations in the connected database.
+ */
+export const PendingSchemaMigrationsError = {
+	title: 'Error: Pending Schema Migrations Detected',
+	description:
+		'Your database has pending schema migrations that need to be applied before proceeding with the migration. Please run the necessary migrations to update your database schema to the latest version before attempting data migration.',
+};
+
+/**
+ * Error case for data migration not being available due to existing data.
+ */
+export const DataMigrationNotAvailableError = {
+	title: 'Error: Data Migration Not Available',
+	description:
+		'Data migration cannot proceed because there is existing data in the target database. Please ensure that the target database is empty before attempting to migrate data.',
+};
+
+/**
+ * Get an array of error cases based on the provided data.
+ *
+ * @param data - An object containing various status indicators.
+ * @returns An array of error case objects.
+ */
+export const getErrorCases = (data: {
+	astroDBTables: string[];
+	astroDbTableKeys: string[];
+	appliedMigrations: number;
+	migrationTotal: number;
+	dataMigrationStatus: {
+		canMigrate: boolean;
+	};
+}) => {
+	return [
+		{
+			condition: data.astroDBTables.length < data.astroDbTableKeys.length,
+			...AstroDbTableError,
+		},
+		{
+			condition: data.appliedMigrations < data.migrationTotal,
+			...PendingSchemaMigrationsError,
+		},
+		{
+			condition: data.dataMigrationStatus.canMigrate === false,
+			...DataMigrationNotAvailableError,
+		},
+	];
+};

package/src/lib/logger.ts

@@ -0,0 +1,4 @@
+import { Logger } from '../../utils/logger.mjs';
+
+export const logger = new Logger({ level: 'info' }, '@studiocms/migrator');
+export default logger;