Merge branch 'alternation-engine' of https://github.com/drizzle-team/drizzle-orm into alternation-engine

Author: OleksiiKH0240

drizzle-kit/src/cli/commands/push-postgres.ts

@@ -21,7 +21,6 @@ import { ddlDiff } from '../../dialects/postgres/diff';
 import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/postgres/drizzle';
 import type { JsonStatement } from '../../dialects/postgres/statements';
 import type { DB } from '../../utils';
-import { mockResolver } from '../../utils/mocks';
 import { prepareFilenames } from '../../utils/utils-node';
 import { resolver } from '../prompts';
 import { Select } from '../selector-ui';
@@ -37,18 +36,36 @@ export const handle = async (
 	strict: boolean,
 	credentials: PostgresCredentials,
 	tablesFilter: string[],
-	schemasFilter: string[],
+	allowedSchemas: string[],
 	entities: Entities,
 	force: boolean,
 	casing: CasingType | undefined,
 ) => {
 	const { preparePostgresDB } = await import('../connections');
-	const { introspect: pgPushIntrospect } = await import('./pull-postgres');
+	const { introspect } = await import('./pull-postgres');
 
 	const db = await preparePostgresDB(credentials);
 	const filenames = prepareFilenames(schemaPath);
 	const res = await prepareFromSchemaFiles(filenames);
 
+	console.log(allowedSchemas);
+	if (allowedSchemas.length > 0) {
+		const toCheck = res.schemas.map((it) => it.schemaName).filter((it) => it !== 'public');
+		const missing = toCheck.filter((it) => !allowedSchemas.includes(it));
+		if (missing.length > 0) {
+			const missingArr = missing.map((it) => chalk.underline(it)).join(', ');
+			const allowedArr = allowedSchemas.map((it) => chalk.underline(it)).join(', ');
+			render(
+				`[${chalk.red('x')}] ${missingArr} schemas missing in drizzle config file "schemaFilter": [${allowedArr}]`,
+			);
+			// TODO: write a guide and link here
+			process.exit(1);
+		}
+	} else {
+		allowedSchemas.push(...res.schemas.map((it) => it.schemaName));
+	}
+	console.log('.', allowedSchemas);
+
 	const { schema: schemaTo, errors, warnings } = fromDrizzleSchema(res, casing);
 
 	if (warnings.length > 0) {
@@ -61,11 +78,11 @@ export const handle = async (
 	}
 
 	const progress = new ProgressView('Pulling schema from database...', 'Pulling schema from database...');
-	const { schema: schemaFrom } = await pgPushIntrospect(db, tablesFilter, schemasFilter, entities, progress);
+	const { schema: schemaFrom } = await introspect(db, tablesFilter, allowedSchemas, entities, progress);
 
 	const { ddl: ddl1, errors: errors1 } = interimToDDL(schemaFrom);
 	const { ddl: ddl2, errors: errors2 } = interimToDDL(schemaTo);
-	// todo: handle errors?
+	// TODO: handle errors?
 
 	if (errors1.length > 0) {
 		console.log(errors.map((it) => postgresSchemaError(it)).join('\n'));

drizzle-kit/src/dialects/cockroach/drizzle.ts

@@ -365,7 +365,12 @@ export const fromDrizzleSchema = (
 				const { dimensions, sqlType, typeSchema, baseColumn } = unwrapColumn(column);
 
 				const columnDefault = defaultFromColumn(baseColumn, column.default, dimensions, dialect);
-				const isPartOfPk = drizzlePKs.find((it) => it.columns.map((it) => it.name).includes(column.name));
+
+				const isPk = column.primary
+					|| config.primaryKeys.find((pk) =>
+							pk.columns.some((col) => col.name ? col.name === column.name : col.keyAsName === column.keyAsName)
+						) !== undefined;
+
 				return {
 					entityType: 'columns',
 					schema: schema,
@@ -376,7 +381,7 @@ export const fromDrizzleSchema = (
 					dimensions: dimensions,
 					pk: column.primary,
 					pkName: null,
-					notNull: notNull || Boolean(isPartOfPk),
+					notNull: notNull || isPk,
 					default: columnDefault,
 					generated: generatedValue,
 					unique: column.isUnique,

drizzle-kit/src/dialects/postgres/drizzle.ts

@@ -268,17 +268,13 @@ export const fromDrizzleSchema = (
 	};
 
 	res.schemas = schema.schemas
+		.filter((it) => {
+			return !it.isExisting && it.schemaName !== 'public';
+		})
 		.map<Schema>((it) => ({
 			entityType: 'schemas',
 			name: it.schemaName,
-		}))
-		.filter((it) => {
-			if (schemaFilter) {
-				return schemaFilter.includes(it.name) && it.name !== 'public';
-			} else {
-				return it.name !== 'public';
-			}
-		});
+		}));
 
 	const tableConfigPairs = schema.tables.map((it) => {
 		return { config: getTableConfig(it), table: it };

drizzle-kit/tests/cockroach/defaults-without-tx.test.ts

@@ -7,20 +7,20 @@ test.concurrent('char + char arrays', async ({ db }) => {
 	// char is less than default
 	const res10 = await diffDefault(db, char({ length: 2 }).default('text'), `'text'`, { expectError: true });
 
-	expect.soft(res1_0).toStrictEqual([`Insert default failed`]);
-	expect.soft(res10).toStrictEqual([`Insert default failed`]);
+	expect(res1_0).toStrictEqual([`Insert default failed`]);
+	expect(res10).toStrictEqual([`Insert default failed`]);
 });
 
 test.concurrent('varchar + varchar arrays', async ({ db }) => {
 	// varchar length is less than default
 	const res10 = await diffDefault(db, varchar({ length: 2 }).default('text'), `'text'`, { expectError: true });
 
-	expect.soft(res10).toStrictEqual([`Insert default failed`]);
+	expect(res10).toStrictEqual([`Insert default failed`]);
 });
 
 test.concurrent('string + string arrays', async ({ db }) => {
 	// varchar length is less than default
 	const res10 = await diffDefault(db, string({ length: 2 }).default('text'), `'text'`, { expectError: true });
 
-	expect.soft(res10).toStrictEqual([`Insert default failed`]);
+	expect(res10).toStrictEqual([`Insert default failed`]);
 });

drizzle-kit/tests/cockroach/generated.test.ts

@@ -3,7 +3,7 @@ import { cockroachTable, int4, text } from 'drizzle-orm/cockroach-core';
 import { expect } from 'vitest';
 import { diff, push, test } from './mocks';
 
-test('generated as callback: add column with generated constraint', async ({ db }) => {
+test.concurrent('generated as callback: add column with generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -37,7 +37,7 @@ test('generated as callback: add column with generated constraint', async ({ db
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as callback: add generated constraint to an exisiting column', async ({ db }) => {
+test.concurrent('generated as callback: add generated constraint to an exisiting column', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -73,7 +73,7 @@ test('generated as callback: add generated constraint to an exisiting column', a
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as callback: drop generated constraint', async ({ db }) => {
+test.concurrent('generated as callback: drop generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -109,7 +109,7 @@ test('generated as callback: drop generated constraint', async ({ db }) => {
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as callback: change generated constraint', async ({ db }) => {
+test.concurrent('generated as callback: change generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -144,7 +144,7 @@ test('generated as callback: change generated constraint', async ({ db }) => {
 	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
 });
 
-test('generated as sql: add column with generated constraint', async ({ db }) => {
+test.concurrent('generated as sql: add column with generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -178,7 +178,7 @@ test('generated as sql: add column with generated constraint', async ({ db }) =>
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as sql: add generated constraint to an exisiting column', async ({ db }) => {
+test.concurrent('generated as sql: add generated constraint to an exisiting column', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -214,7 +214,7 @@ test('generated as sql: add generated constraint to an exisiting column', async
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as sql: drop generated constraint', async ({ db }) => {
+test.concurrent('generated as sql: drop generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -250,7 +250,7 @@ test('generated as sql: drop generated constraint', async ({ db }) => {
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as sql: change generated constraint', async ({ db }) => {
+test.concurrent('generated as sql: change generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -288,7 +288,7 @@ test('generated as sql: change generated constraint', async ({ db }) => {
 	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
 });
 
-test('generated as string: add column with generated constraint', async ({ db }) => {
+test.concurrent('generated as string: add column with generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -322,7 +322,7 @@ test('generated as string: add column with generated constraint', async ({ db })
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as string: add generated constraint to an exisiting column', async ({ db }) => {
+test.concurrent('generated as string: add generated constraint to an exisiting column', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -358,7 +358,7 @@ test('generated as string: add generated constraint to an exisiting column', asy
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as string: drop generated constraint', async ({ db }) => {
+test.concurrent('generated as string: drop generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -394,7 +394,7 @@ test('generated as string: drop generated constraint', async ({ db }) => {
 	expect(pst).toStrictEqual(st0);
 });
 
-test('generated as string: change generated constraint', async ({ db }) => {
+test.concurrent('generated as string: change generated constraint', async ({ db }) => {
 	const from = {
 		users: cockroachTable('users', {
 			id: int4('id'),
@@ -432,7 +432,7 @@ test('generated as string: change generated constraint', async ({ db }) => {
 	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
 });
 
-test('alter generated constraint', async ({ db }) => {
+test.concurrent('alter generated constraint', async ({ db }) => {
 	const schema1 = {
 		users: cockroachTable('users', {
 			id: int4('id'),

drizzle-kit/tests/cockroach/indexes-without-tx.test.ts

@@ -2,7 +2,7 @@ import { cockroachTable, index, int4, vector } from 'drizzle-orm/cockroach-core'
 import { expect } from 'vitest';
 import { diff, push, test } from './mocks';
 
-test.concurrent('vector index', async ({ dbc: db }) => {
+test('vector index', async ({ db }) => {
 	const schema1 = {
 		users: cockroachTable('users', {
 			id: int4('id').primaryKey(),

drizzle-kit/tests/cockroach/mocks.ts

@@ -616,45 +616,41 @@ export const prepareTestDatabase = async (): Promise<TestDatabaseKit> => {
 		await prepareClient(url, 'dbc4', true),
 	];
 
-	const closureTxs = () => {
-		return async () => {
-			while (true) {
-				const c = clientsTxs.shift();
-				if (!c) {
-					await sleep(50);
-					continue;
-				}
-				return {
-					db: c,
-					release: () => {
-						clientsTxs.push(c);
-					},
-				};
+	const closureTxs = async () => {
+		while (true) {
+			const c = clientsTxs.shift();
+			if (!c) {
+				await sleep(50);
+				continue;
 			}
-		};
+			return {
+				db: c,
+				release: () => {
+					clientsTxs.push(c);
+				},
+			};
+		}
 	};
 
-	const closure = () => {
-		return async () => {
-			while (true) {
-				const c = clients.shift();
-				if (!c) {
-					await sleep(50);
-					continue;
-				}
-				return {
-					db: c,
-					release: () => {
-						clients.push(c);
-					},
-				};
+	const closure = async () => {
+		while (true) {
+			const c = clients.shift();
+			if (!c) {
+				await sleep(50);
+				continue;
 			}
-		};
+			return {
+				db: c,
+				release: () => {
+					clients.push(c);
+				},
+			};
+		}
 	};
 
 	return {
-		acquire: closure(),
-		acquireTx: closureTxs(),
+		acquire: closure,
+		acquireTx: closureTxs,
 		close: async () => {
 			for (const c of clients) {
 				c.close();
@@ -680,12 +676,9 @@ export const test = base.extend<{ kit: TestDatabaseKit; db: TestDatabase; dbc: T
 	db: [
 		async ({ kit }, use) => {
 			const { db, release } = await kit.acquire();
-			try {
-				await use(db);
-			} finally {
-				await db.clear();
-				release();
-			}
+			await use(db);
+			await db.clear();
+			release();
 		},
 		{ scope: 'test' },
 	],
@@ -694,12 +687,9 @@ export const test = base.extend<{ kit: TestDatabaseKit; db: TestDatabase; dbc: T
 	dbc: [
 		async ({ kit }, use) => {
 			const { db, release } = await kit.acquireTx();
-			try {
-				await use(db);
-			} finally {
-				await db.clear();
-				release();
-			}
+			await use(db);
+			await db.clear();
+			release();
 		},
 		{ scope: 'test' },
 	],