@anthonyalayo/drizzle-kit 1.0.2 → 1.0.5

package/src/loader.mjs

@@ -1,57 +0,0 @@
-import esbuild from 'esbuild';
-import { readFileSync } from 'fs';
-import * as path from 'path';
-
-const parse = (it) => {
-	if (!it) return { drizzle: false };
-
-	if (it.endsWith('__drizzle__')) {
-		const offset = it.startsWith('file://') ? 'file://'.length : 0;
-		const clean = it.slice(offset, -'__drizzle__'.length);
-		return { drizzle: true, clean, original: it };
-	}
-	return { drizzle: false, clean: it };
-};
-
-export function resolve(specifier, context, nextResolve) {
-	const { drizzle, clean } = parse(specifier);
-	if (drizzle && !clean.endsWith('.ts') && !clean.endsWith('.mts')) {
-		return nextResolve(clean);
-	}
-
-	if (drizzle) {
-		return {
-			shortCircuit: true,
-			url: `file://${specifier}`,
-		};
-	}
-
-	const parsedParent = parse(context.parentURL);
-	const parentURL = parsedParent.drizzle
-		? new URL(`file://${path.resolve(parsedParent.clean)}`)
-		: context.parentURL;
-
-	// Let Node.js handle all other specifiers.
-	return nextResolve(specifier, { ...context, parentURL });
-}
-
-export async function load(url, context, defaultLoad) {
-	const { drizzle, clean } = parse(url);
-	if (drizzle) {
-		const file = readFileSync(clean, 'utf-8');
-		if (clean.endsWith('.ts') || clean.endsWith('.mts')) {
-			const source = esbuild.transformSync(file, {
-				loader: 'ts',
-				format: 'esm',
-			});
-			return {
-				format: 'module',
-				shortCircuit: true,
-				source: source.code,
-			};
-		}
-	}
-
-	// let Node.js handle all other URLs
-	return defaultLoad(url, context, defaultLoad);
-}

package/src/migrationPreparator.ts

@@ -1,217 +0,0 @@
-import { randomUUID } from 'crypto';
-import fs from 'fs';
-import { CasingType } from './cli/validations/common';
-import { serializeMySql, serializePg, serializeSingleStore, serializeSQLite } from './serializer';
-import { dryMySql, MySqlSchema, mysqlSchema } from './serializer/mysqlSchema';
-import { dryPg, PgSchema, pgSchema, PgSchemaInternal } from './serializer/pgSchema';
-import { drySingleStore, SingleStoreSchema, singlestoreSchema } from './serializer/singlestoreSchema';
-import { drySQLite, SQLiteSchema, sqliteSchema } from './serializer/sqliteSchema';
-
-export const prepareMySqlDbPushSnapshot = async (
-	prev: MySqlSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: MySqlSchema; cur: MySqlSchema }> => {
-	const serialized = await serializeMySql(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: MySqlSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	return { prev, cur: result };
-};
-
-export const prepareSingleStoreDbPushSnapshot = async (
-	prev: SingleStoreSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SingleStoreSchema; cur: SingleStoreSchema }> => {
-	const serialized = await serializeSingleStore(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SingleStoreSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	return { prev, cur: result };
-};
-
-export const prepareSQLiteDbPushSnapshot = async (
-	prev: SQLiteSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SQLiteSchema; cur: SQLiteSchema }> => {
-	const serialized = await serializeSQLite(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SQLiteSchema = {
-		version,
-		dialect,
-		id,
-		prevId: idPrev,
-		...rest,
-	};
-
-	return { prev, cur: result };
-};
-
-export const preparePgDbPushSnapshot = async (
-	prev: PgSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-	schemaFilter: string[] = ['public'],
-): Promise<{ prev: PgSchema; cur: PgSchema }> => {
-	const serialized = await serializePg(schemaPath, casing, schemaFilter);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: PgSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	return { prev, cur: result };
-};
-
-export const prepareMySqlMigrationSnapshot = async (
-	migrationFolders: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: MySqlSchema; cur: MySqlSchema; custom: MySqlSchema }> => {
-	const prevSnapshot = mysqlSchema.parse(
-		preparePrevSnapshot(migrationFolders, dryMySql),
-	);
-	const serialized = await serializeMySql(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: MySqlSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: MySqlSchema = {
-		id,
-		prevId: idPrev,
-		...prevRest,
-	};
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-export const prepareSingleStoreMigrationSnapshot = async (
-	migrationFolders: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SingleStoreSchema; cur: SingleStoreSchema; custom: SingleStoreSchema }> => {
-	const prevSnapshot = singlestoreSchema.parse(
-		preparePrevSnapshot(migrationFolders, drySingleStore),
-	);
-	const serialized = await serializeSingleStore(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SingleStoreSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: SingleStoreSchema = {
-		id,
-		prevId: idPrev,
-		...prevRest,
-	};
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-export const prepareSqliteMigrationSnapshot = async (
-	snapshots: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SQLiteSchema; cur: SQLiteSchema; custom: SQLiteSchema }> => {
-	const prevSnapshot = sqliteSchema.parse(
-		preparePrevSnapshot(snapshots, drySQLite),
-	);
-	const serialized = await serializeSQLite(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SQLiteSchema = {
-		version,
-		dialect,
-		id,
-		prevId: idPrev,
-		...rest,
-	};
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: SQLiteSchema = {
-		id,
-		prevId: idPrev,
-		...prevRest,
-	};
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-export const fillPgSnapshot = ({
-	serialized,
-	id,
-	idPrev,
-}: {
-	serialized: PgSchemaInternal;
-	id: string;
-	idPrev: string;
-}): PgSchema => {
-	// const id = randomUUID();
-	return { id, prevId: idPrev, ...serialized };
-};
-
-export const preparePgMigrationSnapshot = async (
-	snapshots: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: PgSchema; cur: PgSchema; custom: PgSchema }> => {
-	const prevSnapshot = pgSchema.parse(preparePrevSnapshot(snapshots, dryPg));
-	const serialized = await serializePg(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	// const { version, dialect, ...rest } = serialized;
-
-	const result: PgSchema = { id, prevId: idPrev, ...serialized };
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: PgSchema = fillPgSnapshot({ serialized: prevRest, id, idPrev });
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-const preparePrevSnapshot = (snapshots: string[], defaultPrev: any) => {
-	let prevSnapshot: any;
-
-	if (snapshots.length === 0) {
-		prevSnapshot = defaultPrev;
-	} else {
-		const lastSnapshot = snapshots[snapshots.length - 1];
-		prevSnapshot = JSON.parse(fs.readFileSync(lastSnapshot).toString());
-	}
-	return prevSnapshot;
-};

package/src/schemaValidator.ts

@@ -1,23 +0,0 @@
-import { enum as enumType, TypeOf, union } from 'zod';
-import { mysqlSchema, mysqlSchemaSquashed } from './serializer/mysqlSchema';
-import { pgSchema, pgSchemaSquashed } from './serializer/pgSchema';
-import { singlestoreSchema, singlestoreSchemaSquashed } from './serializer/singlestoreSchema';
-import { sqliteSchema, SQLiteSchemaSquashed } from './serializer/sqliteSchema';
-
-export const dialects = ['postgresql', 'mysql', 'sqlite', 'turso', 'singlestore'] as const;
-export const dialect = enumType(dialects);
-
-export type Dialect = (typeof dialects)[number];
-const _: Dialect = '' as TypeOf<typeof dialect>;
-
-const commonSquashedSchema = union([
-	pgSchemaSquashed,
-	mysqlSchemaSquashed,
-	SQLiteSchemaSquashed,
-	singlestoreSchemaSquashed,
-]);
-
-const commonSchema = union([pgSchema, mysqlSchema, sqliteSchema, singlestoreSchema]);
-
-export type CommonSquashedSchema = TypeOf<typeof commonSquashedSchema>;
-export type CommonSchema = TypeOf<typeof commonSchema>;

package/src/serializer/index.ts

@@ -1,142 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs';
-import * as glob from 'glob';
-import Path from 'path';
-import { CasingType } from 'src/cli/validations/common';
-import { error } from '../cli/views';
-import type { MySqlSchemaInternal } from './mysqlSchema';
-import type { PgSchemaInternal } from './pgSchema';
-import { SingleStoreSchemaInternal } from './singlestoreSchema';
-import type { SQLiteSchemaInternal } from './sqliteSchema';
-
-export const serializeMySql = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-): Promise<MySqlSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	console.log(chalk.gray(`Reading schema files:\n${filenames.join('\n')}\n`));
-
-	const { prepareFromMySqlImports } = await import('./mysqlImports');
-	const { generateMySqlSnapshot } = await import('./mysqlSerializer');
-
-	const { tables, views } = await prepareFromMySqlImports(filenames);
-
-	return generateMySqlSnapshot(tables, views, casing);
-};
-
-export const serializePg = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-	schemaFilter?: string[],
-): Promise<PgSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	const { prepareFromPgImports } = await import('./pgImports');
-	const { generatePgSnapshot } = await import('./pgSerializer');
-
-	const { tables, domains, enums, schemas, sequences, views, matViews, roles, policies } = await prepareFromPgImports(
-		filenames,
-	);
-
-	return generatePgSnapshot(
-		tables,
-		domains,
-		enums,
-		schemas,
-		sequences,
-		roles,
-		policies,
-		views,
-		matViews,
-		casing,
-		schemaFilter,
-	);
-};
-
-export const serializeSQLite = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-): Promise<SQLiteSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	const { prepareFromSqliteImports } = await import('./sqliteImports');
-	const { generateSqliteSnapshot } = await import('./sqliteSerializer');
-	const { tables, views } = await prepareFromSqliteImports(filenames);
-	return generateSqliteSnapshot(tables, views, casing);
-};
-
-export const serializeSingleStore = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-): Promise<SingleStoreSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	console.log(chalk.gray(`Reading schema files:\n${filenames.join('\n')}\n`));
-
-	const { prepareFromSingleStoreImports } = await import('./singlestoreImports');
-	const { generateSingleStoreSnapshot } = await import('./singlestoreSerializer');
-
-	const { tables /* views */ } = await prepareFromSingleStoreImports(filenames);
-
-	return generateSingleStoreSnapshot(tables, /* views, */ casing);
-};
-
-export const prepareFilenames = (path: string | string[]) => {
-	if (typeof path === 'string') {
-		path = [path];
-	}
-	const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
-
-	const result = path.reduce((result, cur) => {
-		const globbed = glob.sync(`${prefix}${cur}`);
-
-		globbed.forEach((it) => {
-			const fileName = fs.lstatSync(it).isDirectory() ? null : Path.resolve(it);
-
-			const filenames = fileName
-				? [fileName!]
-				: fs.readdirSync(it).map((file) => Path.join(Path.resolve(it), file));
-
-			filenames
-				.filter((file) => !fs.lstatSync(file).isDirectory())
-				.forEach((file) => result.add(file));
-		});
-
-		return result;
-	}, new Set<string>());
-	const res = [...result];
-
-	// TODO: properly handle and test
-	const errors = res.filter((it) => {
-		return !(
-			it.endsWith('.ts')
-			|| it.endsWith('.js')
-			|| it.endsWith('.cjs')
-			|| it.endsWith('.mjs')
-			|| it.endsWith('.mts')
-			|| it.endsWith('.cts')
-		);
-	});
-
-	// when schema: "./schema" and not "./schema.ts"
-	if (res.length === 0) {
-		console.log(
-			error(
-				`No schema files found for path config [${
-					path
-						.map((it) => `'${it}'`)
-						.join(', ')
-				}]`,
-			),
-		);
-		console.log(
-			error(
-				`If path represents a file - please make sure to use .ts or other extension in the path`,
-			),
-		);
-		process.exit(1);
-	}
-
-	return res;
-};

package/src/serializer/mysqlImports.ts

@@ -1,38 +0,0 @@
-import { is } from 'drizzle-orm';
-import { AnyMySqlTable, MySqlTable, MySqlView } from 'drizzle-orm/mysql-core';
-import { safeRegister } from '../cli/commands/utils';
-
-export const prepareFromExports = (exports: Record<string, unknown>) => {
-	const tables: AnyMySqlTable[] = [];
-	const views: MySqlView[] = [];
-
-	const i0values = Object.values(exports);
-	i0values.forEach((t) => {
-		if (is(t, MySqlTable)) {
-			tables.push(t);
-		}
-
-		if (is(t, MySqlView)) {
-			views.push(t);
-		}
-	});
-
-	return { tables, views };
-};
-
-export const prepareFromMySqlImports = async (imports: string[]) => {
-	const tables: AnyMySqlTable[] = [];
-	const views: MySqlView[] = [];
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-		const i0: Record<string, unknown> = require(`${it}`);
-		const prepared = prepareFromExports(i0);
-
-		tables.push(...prepared.tables);
-		views.push(...prepared.views);
-	}
-	unregister();
-	return { tables: Array.from(new Set(tables)), views };
-};