wehub-resource-sync
2785 lines
64 KiB
TypeScript
2785 lines
64 KiB
TypeScript
import { PGlite } from '@electric-sql/pglite';
|
|
import { Client } from '@libsql/client/.';
|
|
import { Database } from 'better-sqlite3';
|
|
import { is } from 'drizzle-orm';
|
|
import { MySqlSchema, MySqlTable, MySqlView } from 'drizzle-orm/mysql-core';
|
|
import {
|
|
getMaterializedViewConfig,
|
|
isPgEnum,
|
|
isPgMaterializedView,
|
|
isPgSequence,
|
|
isPgView,
|
|
PgEnum,
|
|
PgEnumObject,
|
|
PgMaterializedView,
|
|
PgPolicy,
|
|
PgRole,
|
|
PgSchema,
|
|
PgSequence,
|
|
PgTable,
|
|
PgView,
|
|
} from 'drizzle-orm/pg-core';
|
|
import { SingleStoreSchema, SingleStoreTable } from 'drizzle-orm/singlestore-core';
|
|
import { SQLiteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
|
|
import * as fs from 'fs';
|
|
import { type Client as GelClient } from 'gel';
|
|
import { Connection } from 'mysql2/promise';
|
|
import { libSqlLogSuggestionsAndReturn } from 'src/cli/commands/libSqlPushUtils';
|
|
import {
|
|
columnsResolver,
|
|
enumsResolver,
|
|
indPolicyResolver,
|
|
mySqlViewsResolver,
|
|
Named,
|
|
policyResolver,
|
|
roleResolver,
|
|
schemasResolver,
|
|
sequencesResolver,
|
|
sqliteViewsResolver,
|
|
tablesResolver,
|
|
viewsResolver,
|
|
} from 'src/cli/commands/migrate';
|
|
import { pgSuggestions } from 'src/cli/commands/pgPushUtils';
|
|
import { logSuggestionsAndReturn as singleStoreLogSuggestionsAndReturn } from 'src/cli/commands/singlestorePushUtils';
|
|
import { logSuggestionsAndReturn } from 'src/cli/commands/sqlitePushUtils';
|
|
import { Entities } from 'src/cli/validations/cli';
|
|
import { CasingType } from 'src/cli/validations/common';
|
|
import { schemaToTypeScript as schemaToTypeScriptGel } from 'src/introspect-gel';
|
|
import { schemaToTypeScript as schemaToTypeScriptMySQL } from 'src/introspect-mysql';
|
|
import { schemaToTypeScript } from 'src/introspect-pg';
|
|
import { schemaToTypeScript as schemaToTypeScriptSingleStore } from 'src/introspect-singlestore';
|
|
import { schemaToTypeScript as schemaToTypeScriptSQLite } from 'src/introspect-sqlite';
|
|
import { fromDatabase as fromGelDatabase } from 'src/serializer/gelSerializer';
|
|
import { prepareFromMySqlImports } from 'src/serializer/mysqlImports';
|
|
import { mysqlSchema, squashMysqlScheme, ViewSquashed } from 'src/serializer/mysqlSchema';
|
|
import { fromDatabase as fromMySqlDatabase, generateMySqlSnapshot } from 'src/serializer/mysqlSerializer';
|
|
import { prepareFromPgImports } from 'src/serializer/pgImports';
|
|
import { pgSchema, Policy, Role, squashPgScheme, View } from 'src/serializer/pgSchema';
|
|
import { fromDatabase, generatePgSnapshot } from 'src/serializer/pgSerializer';
|
|
import { prepareFromSingleStoreImports } from 'src/serializer/singlestoreImports';
|
|
import { singlestoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
|
|
import {
|
|
fromDatabase as fromSingleStoreDatabase,
|
|
generateSingleStoreSnapshot,
|
|
} from 'src/serializer/singlestoreSerializer';
|
|
import { prepareFromSqliteImports } from 'src/serializer/sqliteImports';
|
|
import { sqliteSchema, squashSqliteScheme, View as SqliteView } from 'src/serializer/sqliteSchema';
|
|
import { fromDatabase as fromSqliteDatabase, generateSqliteSnapshot } from 'src/serializer/sqliteSerializer';
|
|
import {
|
|
applyLibSQLSnapshotsDiff,
|
|
applyMysqlSnapshotsDiff,
|
|
applyPgSnapshotsDiff,
|
|
applySingleStoreSnapshotsDiff,
|
|
applySqliteSnapshotsDiff,
|
|
Column,
|
|
ColumnsResolverInput,
|
|
ColumnsResolverOutput,
|
|
Enum,
|
|
PolicyResolverInput,
|
|
PolicyResolverOutput,
|
|
ResolverInput,
|
|
ResolverOutput,
|
|
ResolverOutputWithMoved,
|
|
RolesResolverInput,
|
|
RolesResolverOutput,
|
|
Sequence,
|
|
Table,
|
|
TablePolicyResolverInput,
|
|
TablePolicyResolverOutput,
|
|
} from 'src/snapshotsDiffer';
|
|
|
|
export type PostgresSchema = Record<
|
|
string,
|
|
| PgTable<any>
|
|
| PgEnum<any>
|
|
| PgEnumObject<any>
|
|
| PgSchema
|
|
| PgSequence
|
|
| PgView
|
|
| PgMaterializedView
|
|
| PgRole
|
|
| PgPolicy
|
|
>;
|
|
export type MysqlSchema = Record<
|
|
string,
|
|
MySqlTable<any> | MySqlSchema | MySqlView
|
|
>;
|
|
export type SqliteSchema = Record<string, SQLiteTable<any> | SQLiteView>;
|
|
export type SinglestoreSchema = Record<
|
|
string,
|
|
SingleStoreTable<any> | SingleStoreSchema /* | SingleStoreView */
|
|
>;
|
|
|
|
export const testSchemasResolver =
|
|
(renames: Set<string>) => async (input: ResolverInput<Named>): Promise<ResolverOutput<Named>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdSchemas = [...input.created];
|
|
let deletedSchemas = [...input.deleted];
|
|
|
|
const result: {
|
|
created: Named[];
|
|
renamed: { from: Named; to: Named }[];
|
|
deleted: Named[];
|
|
} = { created: [], renamed: [], deleted: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedSchemas.findIndex((it) => {
|
|
return it.name === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdSchemas.findIndex((it) => {
|
|
return it.name === to;
|
|
});
|
|
|
|
result.renamed.push({
|
|
from: deletedSchemas[idxFrom],
|
|
to: createdSchemas[idxTo],
|
|
});
|
|
|
|
delete createdSchemas[idxTo];
|
|
delete deletedSchemas[idxFrom];
|
|
|
|
createdSchemas = createdSchemas.filter(Boolean);
|
|
deletedSchemas = deletedSchemas.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdSchemas;
|
|
result.deleted = deletedSchemas;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testSequencesResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<Sequence>,
|
|
): Promise<ResolverOutputWithMoved<Sequence>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdSequences = [...input.created];
|
|
let deletedSequences = [...input.deleted];
|
|
|
|
const result: {
|
|
created: Sequence[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: Sequence; to: Sequence }[];
|
|
deleted: Sequence[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedSequences.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdSequences.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === to;
|
|
});
|
|
|
|
const tableFrom = deletedSequences[idxFrom];
|
|
const tableTo = createdSequences[idxFrom];
|
|
|
|
if (tableFrom.schema !== tableTo.schema) {
|
|
result.moved.push({
|
|
name: tableFrom.name,
|
|
schemaFrom: tableFrom.schema,
|
|
schemaTo: tableTo.schema,
|
|
});
|
|
}
|
|
|
|
if (tableFrom.name !== tableTo.name) {
|
|
result.renamed.push({
|
|
from: deletedSequences[idxFrom],
|
|
to: createdSequences[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdSequences[idxTo];
|
|
delete deletedSequences[idxFrom];
|
|
|
|
createdSequences = createdSequences.filter(Boolean);
|
|
deletedSequences = deletedSequences.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdSequences;
|
|
result.deleted = deletedSequences;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testEnumsResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<Enum>,
|
|
): Promise<ResolverOutputWithMoved<Enum>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdEnums = [...input.created];
|
|
let deletedEnums = [...input.deleted];
|
|
|
|
const result: {
|
|
created: Enum[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: Enum; to: Enum }[];
|
|
deleted: Enum[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedEnums.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdEnums.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === to;
|
|
});
|
|
|
|
const tableFrom = deletedEnums[idxFrom];
|
|
const tableTo = createdEnums[idxFrom];
|
|
|
|
if (tableFrom.schema !== tableTo.schema) {
|
|
result.moved.push({
|
|
name: tableFrom.name,
|
|
schemaFrom: tableFrom.schema,
|
|
schemaTo: tableTo.schema,
|
|
});
|
|
}
|
|
|
|
if (tableFrom.name !== tableTo.name) {
|
|
result.renamed.push({
|
|
from: deletedEnums[idxFrom],
|
|
to: createdEnums[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdEnums[idxTo];
|
|
delete deletedEnums[idxFrom];
|
|
|
|
createdEnums = createdEnums.filter(Boolean);
|
|
deletedEnums = deletedEnums.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdEnums;
|
|
result.deleted = deletedEnums;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testTablesResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<Table>,
|
|
): Promise<ResolverOutputWithMoved<Table>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdTables = [...input.created];
|
|
let deletedTables = [...input.deleted];
|
|
|
|
const result: {
|
|
created: Table[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: Table; to: Table }[];
|
|
deleted: Table[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedTables.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdTables.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === to;
|
|
});
|
|
|
|
const tableFrom = deletedTables[idxFrom];
|
|
const tableTo = createdTables[idxFrom];
|
|
|
|
if (tableFrom.schema !== tableTo.schema) {
|
|
result.moved.push({
|
|
name: tableFrom.name,
|
|
schemaFrom: tableFrom.schema,
|
|
schemaTo: tableTo.schema,
|
|
});
|
|
}
|
|
|
|
if (tableFrom.name !== tableTo.name) {
|
|
result.renamed.push({
|
|
from: deletedTables[idxFrom],
|
|
to: createdTables[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdTables[idxTo];
|
|
delete deletedTables[idxFrom];
|
|
|
|
createdTables = createdTables.filter(Boolean);
|
|
deletedTables = deletedTables.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdTables;
|
|
result.deleted = deletedTables;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testColumnsResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: ColumnsResolverInput<Column>,
|
|
): Promise<ColumnsResolverOutput<Column>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
tableName: input.tableName,
|
|
schema: input.schema,
|
|
created: input.created,
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdColumns = [...input.created];
|
|
let deletedColumns = [...input.deleted];
|
|
|
|
const renamed: { from: Column; to: Column }[] = [];
|
|
|
|
const schema = input.schema || 'public';
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedColumns.findIndex((it) => {
|
|
return `${schema}.${input.tableName}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdColumns.findIndex((it) => {
|
|
return `${schema}.${input.tableName}.${it.name}` === to;
|
|
});
|
|
|
|
renamed.push({
|
|
from: deletedColumns[idxFrom],
|
|
to: createdColumns[idxTo],
|
|
});
|
|
|
|
delete createdColumns[idxTo];
|
|
delete deletedColumns[idxFrom];
|
|
|
|
createdColumns = createdColumns.filter(Boolean);
|
|
deletedColumns = deletedColumns.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
return {
|
|
tableName: input.tableName,
|
|
schema: input.schema,
|
|
created: createdColumns,
|
|
deleted: deletedColumns,
|
|
renamed,
|
|
};
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testPolicyResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: TablePolicyResolverInput<Policy>,
|
|
): Promise<TablePolicyResolverOutput<Policy>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
tableName: input.tableName,
|
|
schema: input.schema,
|
|
created: input.created,
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdPolicies = [...input.created];
|
|
let deletedPolicies = [...input.deleted];
|
|
|
|
const renamed: { from: Policy; to: Policy }[] = [];
|
|
|
|
const schema = input.schema || 'public';
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedPolicies.findIndex((it) => {
|
|
return `${schema}.${input.tableName}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdPolicies.findIndex((it) => {
|
|
return `${schema}.${input.tableName}.${it.name}` === to;
|
|
});
|
|
|
|
renamed.push({
|
|
from: deletedPolicies[idxFrom],
|
|
to: createdPolicies[idxTo],
|
|
});
|
|
|
|
delete createdPolicies[idxTo];
|
|
delete deletedPolicies[idxFrom];
|
|
|
|
createdPolicies = createdPolicies.filter(Boolean);
|
|
deletedPolicies = deletedPolicies.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
return {
|
|
tableName: input.tableName,
|
|
schema: input.schema,
|
|
created: createdPolicies,
|
|
deleted: deletedPolicies,
|
|
renamed,
|
|
};
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testIndPolicyResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: PolicyResolverInput<Policy>,
|
|
): Promise<PolicyResolverOutput<Policy>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdPolicies = [...input.created];
|
|
let deletedPolicies = [...input.deleted];
|
|
|
|
const renamed: { from: Policy; to: Policy }[] = [];
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedPolicies.findIndex((it) => {
|
|
return `${it.on}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdPolicies.findIndex((it) => {
|
|
return `${it.on}.${it.name}` === to;
|
|
});
|
|
|
|
renamed.push({
|
|
from: deletedPolicies[idxFrom],
|
|
to: createdPolicies[idxTo],
|
|
});
|
|
|
|
delete createdPolicies[idxTo];
|
|
delete deletedPolicies[idxFrom];
|
|
|
|
createdPolicies = createdPolicies.filter(Boolean);
|
|
deletedPolicies = deletedPolicies.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
return {
|
|
created: createdPolicies,
|
|
deleted: deletedPolicies,
|
|
renamed,
|
|
};
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testRolesResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: RolesResolverInput<Role>,
|
|
): Promise<RolesResolverOutput<Role>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdPolicies = [...input.created];
|
|
let deletedPolicies = [...input.deleted];
|
|
|
|
const renamed: { from: Policy; to: Policy }[] = [];
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedPolicies.findIndex((it) => {
|
|
return `${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdPolicies.findIndex((it) => {
|
|
return `${it.name}` === to;
|
|
});
|
|
|
|
renamed.push({
|
|
from: deletedPolicies[idxFrom],
|
|
to: createdPolicies[idxTo],
|
|
});
|
|
|
|
delete createdPolicies[idxTo];
|
|
delete deletedPolicies[idxFrom];
|
|
|
|
createdPolicies = createdPolicies.filter(Boolean);
|
|
deletedPolicies = deletedPolicies.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
return {
|
|
created: createdPolicies,
|
|
deleted: deletedPolicies,
|
|
renamed,
|
|
};
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testViewsResolver = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<View>,
|
|
): Promise<ResolverOutputWithMoved<View>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdViews = [...input.created];
|
|
let deletedViews = [...input.deleted];
|
|
|
|
const result: {
|
|
created: View[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: View; to: View }[];
|
|
deleted: View[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedViews.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdViews.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === to;
|
|
});
|
|
|
|
const viewFrom = deletedViews[idxFrom];
|
|
const viewTo = createdViews[idxFrom];
|
|
|
|
if (viewFrom.schema !== viewTo.schema) {
|
|
result.moved.push({
|
|
name: viewFrom.name,
|
|
schemaFrom: viewFrom.schema,
|
|
schemaTo: viewTo.schema,
|
|
});
|
|
}
|
|
|
|
if (viewFrom.name !== viewTo.name) {
|
|
result.renamed.push({
|
|
from: deletedViews[idxFrom],
|
|
to: createdViews[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdViews[idxTo];
|
|
delete deletedViews[idxFrom];
|
|
|
|
createdViews = createdViews.filter(Boolean);
|
|
deletedViews = deletedViews.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdViews;
|
|
result.deleted = deletedViews;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testViewsResolverMySql = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<ViewSquashed & { schema: '' }>,
|
|
): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdViews = [...input.created];
|
|
let deletedViews = [...input.deleted];
|
|
|
|
const result: {
|
|
created: ViewSquashed[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: ViewSquashed; to: ViewSquashed }[];
|
|
deleted: ViewSquashed[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedViews.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdViews.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === to;
|
|
});
|
|
|
|
const viewFrom = deletedViews[idxFrom];
|
|
const viewTo = createdViews[idxFrom];
|
|
|
|
if (viewFrom.schema !== viewTo.schema) {
|
|
result.moved.push({
|
|
name: viewFrom.name,
|
|
schemaFrom: viewFrom.schema,
|
|
schemaTo: viewTo.schema,
|
|
});
|
|
}
|
|
|
|
if (viewFrom.name !== viewTo.name) {
|
|
result.renamed.push({
|
|
from: deletedViews[idxFrom],
|
|
to: createdViews[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdViews[idxTo];
|
|
delete deletedViews[idxFrom];
|
|
|
|
createdViews = createdViews.filter(Boolean);
|
|
deletedViews = deletedViews.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdViews;
|
|
result.deleted = deletedViews;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testViewsResolverSingleStore = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<ViewSquashed & { schema: '' }>,
|
|
): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdViews = [...input.created];
|
|
let deletedViews = [...input.deleted];
|
|
|
|
const result: {
|
|
created: ViewSquashed[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: ViewSquashed; to: ViewSquashed }[];
|
|
deleted: ViewSquashed[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedViews.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdViews.findIndex((it) => {
|
|
return `${it.schema || 'public'}.${it.name}` === to;
|
|
});
|
|
|
|
const viewFrom = deletedViews[idxFrom];
|
|
const viewTo = createdViews[idxFrom];
|
|
|
|
if (viewFrom.schema !== viewTo.schema) {
|
|
result.moved.push({
|
|
name: viewFrom.name,
|
|
schemaFrom: viewFrom.schema,
|
|
schemaTo: viewTo.schema,
|
|
});
|
|
}
|
|
|
|
if (viewFrom.name !== viewTo.name) {
|
|
result.renamed.push({
|
|
from: deletedViews[idxFrom],
|
|
to: createdViews[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdViews[idxTo];
|
|
delete deletedViews[idxFrom];
|
|
|
|
createdViews = createdViews.filter(Boolean);
|
|
deletedViews = deletedViews.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdViews;
|
|
result.deleted = deletedViews;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const testViewsResolverSqlite = (renames: Set<string>) =>
|
|
async (
|
|
input: ResolverInput<SqliteView>,
|
|
): Promise<ResolverOutputWithMoved<SqliteView>> => {
|
|
try {
|
|
if (
|
|
input.created.length === 0
|
|
|| input.deleted.length === 0
|
|
|| renames.size === 0
|
|
) {
|
|
return {
|
|
created: input.created,
|
|
moved: [],
|
|
renamed: [],
|
|
deleted: input.deleted,
|
|
};
|
|
}
|
|
|
|
let createdViews = [...input.created];
|
|
let deletedViews = [...input.deleted];
|
|
|
|
const result: {
|
|
created: SqliteView[];
|
|
moved: { name: string; schemaFrom: string; schemaTo: string }[];
|
|
renamed: { from: SqliteView; to: SqliteView }[];
|
|
deleted: SqliteView[];
|
|
} = { created: [], renamed: [], deleted: [], moved: [] };
|
|
|
|
for (let rename of renames) {
|
|
const [from, to] = rename.split('->');
|
|
|
|
const idxFrom = deletedViews.findIndex((it) => {
|
|
return it.name === from;
|
|
});
|
|
|
|
if (idxFrom >= 0) {
|
|
const idxTo = createdViews.findIndex((it) => {
|
|
return it.name === to;
|
|
});
|
|
|
|
const viewFrom = deletedViews[idxFrom];
|
|
const viewTo = createdViews[idxFrom];
|
|
|
|
if (viewFrom.name !== viewTo.name) {
|
|
result.renamed.push({
|
|
from: deletedViews[idxFrom],
|
|
to: createdViews[idxTo],
|
|
});
|
|
}
|
|
|
|
delete createdViews[idxTo];
|
|
delete deletedViews[idxFrom];
|
|
|
|
createdViews = createdViews.filter(Boolean);
|
|
deletedViews = deletedViews.filter(Boolean);
|
|
}
|
|
}
|
|
|
|
result.created = createdViews;
|
|
result.deleted = deletedViews;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
export const diffTestSchemasPush = async (
|
|
client: PGlite,
|
|
left: PostgresSchema,
|
|
right: PostgresSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
schemas: string[] = ['public'],
|
|
casing?: CasingType | undefined,
|
|
entities?: Entities,
|
|
sqlStatementsToRun: {
|
|
before?: string[];
|
|
after?: string[];
|
|
runApply?: boolean;
|
|
} = {
|
|
before: [],
|
|
after: [],
|
|
runApply: true,
|
|
},
|
|
) => {
|
|
const shouldRunApply = sqlStatementsToRun.runApply === undefined
|
|
? true
|
|
: sqlStatementsToRun.runApply;
|
|
|
|
for (const st of sqlStatementsToRun.before ?? []) {
|
|
await client.query(st);
|
|
}
|
|
|
|
if (shouldRunApply) {
|
|
const res = await applyPgDiffs(left, casing);
|
|
for (const st of res.sqlStatements) {
|
|
await client.query(st);
|
|
}
|
|
}
|
|
|
|
for (const st of sqlStatementsToRun.after ?? []) {
|
|
await client.query(st);
|
|
}
|
|
|
|
const materializedViewsForRefresh = Object.values(left).filter((it) =>
|
|
isPgMaterializedView(it)
|
|
) as PgMaterializedView[];
|
|
|
|
// refresh all mat views
|
|
for (const view of materializedViewsForRefresh) {
|
|
const viewConf = getMaterializedViewConfig(view);
|
|
if (viewConf.isExisting) continue;
|
|
|
|
await client.exec(
|
|
`REFRESH MATERIALIZED VIEW "${viewConf.schema ?? 'public'}"."${viewConf.name}"${
|
|
viewConf.withNoData ? ' WITH NO DATA;' : ';'
|
|
}`,
|
|
);
|
|
}
|
|
|
|
// do introspect into PgSchemaInternal
|
|
const introspectedSchema = await fromDatabase(
|
|
{
|
|
query: async (query: string, values?: any[] | undefined) => {
|
|
const res = await client.query(query, values);
|
|
return res.rows as any[];
|
|
},
|
|
},
|
|
undefined,
|
|
schemas,
|
|
entities,
|
|
);
|
|
|
|
const leftTables = Object.values(right).filter((it) => is(it, PgTable)) as PgTable[];
|
|
|
|
const leftSchemas = Object.values(right).filter((it) => is(it, PgSchema)) as PgSchema[];
|
|
|
|
const leftEnums = Object.values(right).filter((it) => isPgEnum(it)) as PgEnum<any>[];
|
|
|
|
const leftSequences = Object.values(right).filter((it) => isPgSequence(it)) as PgSequence[];
|
|
|
|
const leftRoles = Object.values(right).filter((it) => is(it, PgRole)) as PgRole[];
|
|
|
|
const leftPolicies = Object.values(right).filter((it) => is(it, PgPolicy)) as PgPolicy[];
|
|
|
|
const leftViews = Object.values(right).filter((it) => isPgView(it)) as PgView[];
|
|
|
|
const leftMaterializedViews = Object.values(right).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
|
|
|
|
const serialized2 = generatePgSnapshot(
|
|
leftTables,
|
|
leftEnums,
|
|
leftSchemas,
|
|
leftSequences,
|
|
leftRoles,
|
|
leftPolicies,
|
|
leftViews,
|
|
leftMaterializedViews,
|
|
casing,
|
|
);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashPgScheme(sch1, 'push');
|
|
const sn2 = squashPgScheme(sch2, 'push');
|
|
|
|
const validatedPrev = pgSchema.parse(sch1);
|
|
const validatedCur = pgSchema.parse(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applyPgSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testSchemasResolver(renames),
|
|
testEnumsResolver(renames),
|
|
testSequencesResolver(renames),
|
|
testPolicyResolver(renames),
|
|
testIndPolicyResolver(renames),
|
|
testRolesResolver(renames),
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolver(renames),
|
|
validatedPrev,
|
|
validatedCur,
|
|
'push',
|
|
);
|
|
|
|
const {
|
|
shouldAskForApprove,
|
|
statementsToExecute,
|
|
columnsToRemove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
infoToPrint,
|
|
schemasToRemove,
|
|
matViewsToRemove,
|
|
} = await pgSuggestions(
|
|
{
|
|
query: async <T>(sql: string, params: any[] = []) => {
|
|
return (await client.query(sql, params)).rows as T[];
|
|
},
|
|
},
|
|
statements,
|
|
);
|
|
|
|
return {
|
|
sqlStatements: statementsToExecute,
|
|
statements,
|
|
shouldAskForApprove,
|
|
columnsToRemove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
infoToPrint,
|
|
schemasToRemove,
|
|
matViewsToRemove,
|
|
};
|
|
} else {
|
|
const { sqlStatements, statements } = await applyPgSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
schemasResolver,
|
|
enumsResolver,
|
|
sequencesResolver,
|
|
policyResolver,
|
|
indPolicyResolver,
|
|
roleResolver,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
viewsResolver,
|
|
validatedPrev,
|
|
validatedCur,
|
|
'push',
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
};
|
|
|
|
export const applyPgDiffs = async (
|
|
sn: PostgresSchema,
|
|
casing: CasingType | undefined,
|
|
) => {
|
|
const dryRun = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
tables: {},
|
|
enums: {},
|
|
views: {},
|
|
schemas: {},
|
|
sequences: {},
|
|
policies: {},
|
|
roles: {},
|
|
_meta: {
|
|
schemas: {},
|
|
tables: {},
|
|
columns: {},
|
|
},
|
|
} as const;
|
|
|
|
const tables = Object.values(sn).filter((it) => is(it, PgTable)) as PgTable[];
|
|
|
|
const schemas = Object.values(sn).filter((it) => is(it, PgSchema)) as PgSchema[];
|
|
|
|
const enums = Object.values(sn).filter((it) => isPgEnum(it)) as PgEnum<any>[];
|
|
|
|
const sequences = Object.values(sn).filter((it) => isPgSequence(it)) as PgSequence[];
|
|
|
|
const roles = Object.values(sn).filter((it) => is(it, PgRole)) as PgRole[];
|
|
|
|
const views = Object.values(sn).filter((it) => isPgView(it)) as PgView[];
|
|
|
|
const policies = Object.values(sn).filter((it) => is(it, PgPolicy)) as PgPolicy[];
|
|
|
|
const materializedViews = Object.values(sn).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
|
|
|
|
const serialized1 = generatePgSnapshot(
|
|
tables,
|
|
enums,
|
|
schemas,
|
|
sequences,
|
|
roles,
|
|
policies,
|
|
views,
|
|
materializedViews,
|
|
casing,
|
|
);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
|
|
const sch1 = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sn1 = squashPgScheme(sch1);
|
|
|
|
const validatedPrev = pgSchema.parse(dryRun);
|
|
const validatedCur = pgSchema.parse(sch1);
|
|
|
|
const { sqlStatements, statements } = await applyPgSnapshotsDiff(
|
|
dryRun,
|
|
sn1,
|
|
testSchemasResolver(new Set()),
|
|
testEnumsResolver(new Set()),
|
|
testSequencesResolver(new Set()),
|
|
testPolicyResolver(new Set()),
|
|
testIndPolicyResolver(new Set()),
|
|
testRolesResolver(new Set()),
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolver(new Set()),
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemas = async (
|
|
left: PostgresSchema,
|
|
right: PostgresSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const leftTables = Object.values(left).filter((it) => is(it, PgTable)) as PgTable[];
|
|
|
|
const rightTables = Object.values(right).filter((it) => is(it, PgTable)) as PgTable[];
|
|
|
|
const leftSchemas = Object.values(left).filter((it) => is(it, PgSchema)) as PgSchema[];
|
|
|
|
const rightSchemas = Object.values(right).filter((it) => is(it, PgSchema)) as PgSchema[];
|
|
|
|
const leftEnums = Object.values(left).filter((it) => isPgEnum(it)) as PgEnum<any>[];
|
|
|
|
const rightEnums = Object.values(right).filter((it) => isPgEnum(it)) as PgEnum<any>[];
|
|
|
|
const leftSequences = Object.values(left).filter((it) => isPgSequence(it)) as PgSequence[];
|
|
|
|
const rightSequences = Object.values(right).filter((it) => isPgSequence(it)) as PgSequence[];
|
|
|
|
const leftRoles = Object.values(left).filter((it) => is(it, PgRole)) as PgRole[];
|
|
|
|
const rightRoles = Object.values(right).filter((it) => is(it, PgRole)) as PgRole[];
|
|
|
|
const leftPolicies = Object.values(left).filter((it) => is(it, PgPolicy)) as PgPolicy[];
|
|
|
|
const rightPolicies = Object.values(right).filter((it) => is(it, PgPolicy)) as PgPolicy[];
|
|
|
|
const leftViews = Object.values(left).filter((it) => isPgView(it)) as PgView[];
|
|
|
|
const rightViews = Object.values(right).filter((it) => isPgView(it)) as PgView[];
|
|
|
|
const leftMaterializedViews = Object.values(left).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
|
|
|
|
const rightMaterializedViews = Object.values(right).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
|
|
|
|
const serialized1 = generatePgSnapshot(
|
|
leftTables,
|
|
leftEnums,
|
|
leftSchemas,
|
|
leftSequences,
|
|
leftRoles,
|
|
leftPolicies,
|
|
leftViews,
|
|
leftMaterializedViews,
|
|
casing,
|
|
);
|
|
const serialized2 = generatePgSnapshot(
|
|
rightTables,
|
|
rightEnums,
|
|
rightSchemas,
|
|
rightSequences,
|
|
rightRoles,
|
|
rightPolicies,
|
|
rightViews,
|
|
rightMaterializedViews,
|
|
casing,
|
|
);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashPgScheme(sch1);
|
|
const sn2 = squashPgScheme(sch2);
|
|
|
|
const validatedPrev = pgSchema.parse(sch1);
|
|
const validatedCur = pgSchema.parse(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applyPgSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testSchemasResolver(renames),
|
|
testEnumsResolver(renames),
|
|
testSequencesResolver(renames),
|
|
testPolicyResolver(renames),
|
|
testIndPolicyResolver(renames),
|
|
testRolesResolver(renames),
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolver(renames),
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
} else {
|
|
const { sqlStatements, statements } = await applyPgSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
schemasResolver,
|
|
enumsResolver,
|
|
sequencesResolver,
|
|
policyResolver,
|
|
indPolicyResolver,
|
|
roleResolver,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
viewsResolver,
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
};
|
|
|
|
export const diffTestSchemasPushMysql = async (
|
|
client: Connection,
|
|
left: MysqlSchema,
|
|
right: MysqlSchema,
|
|
renamesArr: string[],
|
|
schema: string,
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const { sqlStatements } = await applyMySqlDiffs(left, casing);
|
|
for (const st of sqlStatements) {
|
|
await client.query(st);
|
|
}
|
|
// do introspect into PgSchemaInternal
|
|
const introspectedSchema = await fromMySqlDatabase(
|
|
{
|
|
query: async (sql: string, params?: any[]) => {
|
|
const res = await client.execute(sql, params);
|
|
return res[0] as any;
|
|
},
|
|
},
|
|
schema,
|
|
);
|
|
|
|
const leftTables = Object.values(right).filter((it) => is(it, MySqlTable)) as MySqlTable[];
|
|
|
|
const leftViews = Object.values(right).filter((it) => is(it, MySqlView)) as MySqlView[];
|
|
|
|
const serialized2 = generateMySqlSnapshot(leftTables, leftViews, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashMysqlScheme(sch1);
|
|
const sn2 = squashMysqlScheme(sch2);
|
|
|
|
const validatedPrev = mysqlSchema.parse(sch1);
|
|
const validatedCur = mysqlSchema.parse(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolverMySql(renames),
|
|
validatedPrev,
|
|
validatedCur,
|
|
'push',
|
|
);
|
|
return { sqlStatements, statements };
|
|
} else {
|
|
const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
mySqlViewsResolver,
|
|
validatedPrev,
|
|
validatedCur,
|
|
'push',
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
};
|
|
|
|
export const applyMySqlDiffs = async (
|
|
sn: MysqlSchema,
|
|
casing: CasingType | undefined,
|
|
) => {
|
|
const dryRun = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
views: {},
|
|
tables: {},
|
|
enums: {},
|
|
schemas: {},
|
|
_meta: {
|
|
schemas: {},
|
|
tables: {},
|
|
columns: {},
|
|
},
|
|
} as const;
|
|
|
|
const tables = Object.values(sn).filter((it) => is(it, MySqlTable)) as MySqlTable[];
|
|
|
|
const views = Object.values(sn).filter((it) => is(it, MySqlView)) as MySqlView[];
|
|
|
|
const serialized1 = generateMySqlSnapshot(tables, views, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
|
|
const sch1 = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sn1 = squashMysqlScheme(sch1);
|
|
|
|
const validatedPrev = mysqlSchema.parse(dryRun);
|
|
const validatedCur = mysqlSchema.parse(sch1);
|
|
|
|
const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
|
|
dryRun,
|
|
sn1,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolverMySql(new Set()),
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemasMysql = async (
|
|
left: MysqlSchema,
|
|
right: MysqlSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const leftTables = Object.values(left).filter((it) => is(it, MySqlTable)) as MySqlTable[];
|
|
|
|
const leftViews = Object.values(left).filter((it) => is(it, MySqlView)) as MySqlView[];
|
|
|
|
const rightTables = Object.values(right).filter((it) => is(it, MySqlTable)) as MySqlTable[];
|
|
|
|
const rightViews = Object.values(right).filter((it) => is(it, MySqlView)) as MySqlView[];
|
|
|
|
const serialized1 = generateMySqlSnapshot(leftTables, leftViews, casing);
|
|
const serialized2 = generateMySqlSnapshot(rightTables, rightViews, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashMysqlScheme(sch1);
|
|
const sn2 = squashMysqlScheme(sch2);
|
|
|
|
const validatedPrev = mysqlSchema.parse(sch1);
|
|
const validatedCur = mysqlSchema.parse(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolverMySql(renames),
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
|
|
const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
mySqlViewsResolver,
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemasSingleStore = async (
|
|
left: SinglestoreSchema,
|
|
right: SinglestoreSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const leftTables = Object.values(left).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
|
|
|
|
/* const leftViews = Object.values(left).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
|
|
|
|
const rightTables = Object.values(right).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
|
|
|
|
/* const rightViews = Object.values(right).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
|
|
|
|
const serialized1 = generateSingleStoreSnapshot(
|
|
leftTables,
|
|
/* leftViews, */
|
|
casing,
|
|
);
|
|
const serialized2 = generateSingleStoreSnapshot(
|
|
rightTables,
|
|
/* rightViews, */
|
|
casing,
|
|
);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashSingleStoreScheme(sch1);
|
|
const sn2 = squashSingleStoreScheme(sch2);
|
|
|
|
const validatedPrev = singlestoreSchema.parse(sch1);
|
|
const validatedCur = singlestoreSchema.parse(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
/* testViewsResolverSingleStore(renames), */
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
|
|
const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
/* singleStoreViewsResolver, */
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemasPushSingleStore = async (
|
|
client: Connection,
|
|
left: SinglestoreSchema,
|
|
right: SinglestoreSchema,
|
|
renamesArr: string[],
|
|
schema: string,
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
sqlStatementsToRun: {
|
|
before?: string[];
|
|
after?: string[];
|
|
runApply?: boolean;
|
|
} = {
|
|
before: [],
|
|
after: [],
|
|
runApply: true,
|
|
},
|
|
) => {
|
|
const shouldRunApply = sqlStatementsToRun.runApply === undefined
|
|
? true
|
|
: sqlStatementsToRun.runApply;
|
|
|
|
for (const st of sqlStatementsToRun.before ?? []) {
|
|
await client.query(st);
|
|
}
|
|
|
|
if (shouldRunApply) {
|
|
const res = await applySingleStoreDiffs(left, casing);
|
|
for (const st of res.sqlStatements) {
|
|
await client.query(st);
|
|
}
|
|
}
|
|
|
|
for (const st of sqlStatementsToRun.after ?? []) {
|
|
await client.query(st);
|
|
}
|
|
|
|
// do introspect into PgSchemaInternal
|
|
const introspectedSchema = await fromSingleStoreDatabase(
|
|
{
|
|
query: async (sql: string, params?: any[]) => {
|
|
const res = await client.execute(sql, params);
|
|
return res[0] as any;
|
|
},
|
|
},
|
|
schema,
|
|
);
|
|
|
|
const leftTables = Object.values(right).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
|
|
|
|
/* const leftViews = Object.values(right).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
|
|
|
|
const serialized2 = generateSingleStoreSnapshot(
|
|
leftTables,
|
|
/* leftViews, */
|
|
casing,
|
|
);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashSingleStoreScheme(sch1);
|
|
const sn2 = squashSingleStoreScheme(sch2);
|
|
|
|
const validatedPrev = singlestoreSchema.parse(sch1);
|
|
const validatedCur = singlestoreSchema.parse(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
/* testViewsResolverSingleStore(renames), */
|
|
validatedPrev,
|
|
validatedCur,
|
|
'push',
|
|
);
|
|
|
|
const {
|
|
statementsToExecute,
|
|
columnsToRemove,
|
|
infoToPrint,
|
|
shouldAskForApprove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
} = await singleStoreLogSuggestionsAndReturn(
|
|
{
|
|
query: async <T>(sql: string, params?: any[]) => {
|
|
const res = await client.execute(sql, params);
|
|
return res[0] as T[];
|
|
},
|
|
},
|
|
statements,
|
|
sn1,
|
|
sn2,
|
|
);
|
|
|
|
return {
|
|
sqlStatements: statementsToExecute,
|
|
statements,
|
|
columnsToRemove,
|
|
infoToPrint,
|
|
shouldAskForApprove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
};
|
|
} else {
|
|
const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
/* singleStoreViewsResolver, */
|
|
validatedPrev,
|
|
validatedCur,
|
|
'push',
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
};
|
|
|
|
export const applySingleStoreDiffs = async (
|
|
sn: SinglestoreSchema,
|
|
casing: CasingType | undefined,
|
|
) => {
|
|
const dryRun = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
tables: {},
|
|
views: {},
|
|
enums: {},
|
|
schemas: {},
|
|
_meta: {
|
|
schemas: {},
|
|
tables: {},
|
|
columns: {},
|
|
},
|
|
} as const;
|
|
|
|
const tables = Object.values(sn).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
|
|
|
|
/* const views = Object.values(sn).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
|
|
|
|
const serialized1 = generateSingleStoreSnapshot(tables, /* views, */ casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
|
|
const sch1 = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sn1 = squashSingleStoreScheme(sch1);
|
|
|
|
const validatedPrev = singlestoreSchema.parse(dryRun);
|
|
const validatedCur = singlestoreSchema.parse(sch1);
|
|
|
|
const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
|
|
dryRun,
|
|
sn1,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
/* testViewsResolverSingleStore(new Set()), */
|
|
validatedPrev,
|
|
validatedCur,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemasPushSqlite = async (
|
|
client: Database,
|
|
left: SqliteSchema,
|
|
right: SqliteSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
seedStatements: string[] = [],
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const { sqlStatements } = await applySqliteDiffs(left, 'push');
|
|
|
|
for (const st of sqlStatements) {
|
|
client.exec(st);
|
|
}
|
|
|
|
for (const st of seedStatements) {
|
|
client.exec(st);
|
|
}
|
|
|
|
// do introspect into PgSchemaInternal
|
|
const introspectedSchema = await fromSqliteDatabase(
|
|
{
|
|
query: async <T>(sql: string, params: any[] = []) => {
|
|
return client.prepare(sql).bind(params).all() as T[];
|
|
},
|
|
run: async (query: string) => {
|
|
client.prepare(query).run();
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
|
|
const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashSqliteScheme(sch1, 'push');
|
|
const sn2 = squashSqliteScheme(sch2, 'push');
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements, _meta } = await applySqliteSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolverSqlite(renames),
|
|
sch1,
|
|
sch2,
|
|
'push',
|
|
);
|
|
|
|
const {
|
|
statementsToExecute,
|
|
columnsToRemove,
|
|
infoToPrint,
|
|
schemasToRemove,
|
|
shouldAskForApprove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
} = await logSuggestionsAndReturn(
|
|
{
|
|
query: async <T>(sql: string, params: any[] = []) => {
|
|
return client.prepare(sql).bind(params).all() as T[];
|
|
},
|
|
run: async (query: string) => {
|
|
client.prepare(query).run();
|
|
},
|
|
},
|
|
statements,
|
|
sn1,
|
|
sn2,
|
|
_meta!,
|
|
);
|
|
|
|
return {
|
|
sqlStatements: statementsToExecute,
|
|
statements,
|
|
columnsToRemove,
|
|
infoToPrint,
|
|
schemasToRemove,
|
|
shouldAskForApprove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
};
|
|
} else {
|
|
const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
sqliteViewsResolver,
|
|
sch1,
|
|
sch2,
|
|
'push',
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
};
|
|
|
|
export async function diffTestSchemasPushLibSQL(
|
|
client: Client,
|
|
left: SqliteSchema,
|
|
right: SqliteSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
seedStatements: string[] = [],
|
|
casing?: CasingType | undefined,
|
|
) {
|
|
const { sqlStatements } = await applyLibSQLDiffs(left, 'push');
|
|
|
|
for (const st of sqlStatements) {
|
|
await client.execute(st);
|
|
}
|
|
|
|
for (const st of seedStatements) {
|
|
await client.execute(st);
|
|
}
|
|
|
|
const introspectedSchema = await fromSqliteDatabase(
|
|
{
|
|
query: async <T>(sql: string, params?: any[]) => {
|
|
const res = await client.execute({ sql, args: params || [] });
|
|
return res.rows as T[];
|
|
},
|
|
run: async (query: string) => {
|
|
await client.execute(query);
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
|
|
const leftTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const leftViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const serialized2 = generateSqliteSnapshot(leftTables, leftViews, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashSqliteScheme(sch1, 'push');
|
|
const sn2 = squashSqliteScheme(sch2, 'push');
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements, _meta } = await applyLibSQLSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolverSqlite(renames),
|
|
sch1,
|
|
sch2,
|
|
'push',
|
|
);
|
|
|
|
const {
|
|
statementsToExecute,
|
|
columnsToRemove,
|
|
infoToPrint,
|
|
shouldAskForApprove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
} = await libSqlLogSuggestionsAndReturn(
|
|
{
|
|
query: async <T>(sql: string, params?: any[]) => {
|
|
const res = await client.execute({ sql, args: params || [] });
|
|
return res.rows as T[];
|
|
},
|
|
run: async (query: string) => {
|
|
await client.execute(query);
|
|
},
|
|
},
|
|
statements,
|
|
sn1,
|
|
sn2,
|
|
_meta!,
|
|
);
|
|
|
|
return {
|
|
sqlStatements: statementsToExecute,
|
|
statements,
|
|
columnsToRemove,
|
|
infoToPrint,
|
|
shouldAskForApprove,
|
|
tablesToRemove,
|
|
tablesToTruncate,
|
|
};
|
|
} else {
|
|
const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
sqliteViewsResolver,
|
|
sch1,
|
|
sch2,
|
|
'push',
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
}
|
|
|
|
export const applySqliteDiffs = async (
|
|
sn: SqliteSchema,
|
|
action?: 'push' | undefined,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const dryRun = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
tables: {},
|
|
enums: {},
|
|
views: {},
|
|
schemas: {},
|
|
_meta: {
|
|
schemas: {},
|
|
tables: {},
|
|
columns: {},
|
|
},
|
|
} as const;
|
|
|
|
const tables = Object.values(sn).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const views = Object.values(sn).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const serialized1 = generateSqliteSnapshot(tables, views, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
|
|
const sch1 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sn1 = squashSqliteScheme(sch1, action);
|
|
|
|
const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
|
|
dryRun,
|
|
sn1,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolverSqlite(new Set()),
|
|
dryRun,
|
|
sch1,
|
|
action,
|
|
);
|
|
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const applyLibSQLDiffs = async (
|
|
sn: SqliteSchema,
|
|
action?: 'push' | undefined,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const dryRun = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
tables: {},
|
|
views: {},
|
|
enums: {},
|
|
schemas: {},
|
|
_meta: {
|
|
schemas: {},
|
|
tables: {},
|
|
columns: {},
|
|
},
|
|
} as const;
|
|
|
|
const tables = Object.values(sn).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const views = Object.values(sn).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const serialized1 = generateSqliteSnapshot(tables, views, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
|
|
const sch1 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sn1 = squashSqliteScheme(sch1, action);
|
|
|
|
const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
|
|
dryRun,
|
|
sn1,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolverSqlite(new Set()),
|
|
dryRun,
|
|
sch1,
|
|
action,
|
|
);
|
|
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemasSqlite = async (
|
|
left: SqliteSchema,
|
|
right: SqliteSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const leftTables = Object.values(left).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const leftViews = Object.values(left).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const serialized1 = generateSqliteSnapshot(leftTables, leftViews, casing);
|
|
const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashSqliteScheme(sch1);
|
|
const sn2 = squashSqliteScheme(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolverSqlite(renames),
|
|
sch1,
|
|
sch2,
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
|
|
const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
sqliteViewsResolver,
|
|
sch1,
|
|
sch2,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
export const diffTestSchemasLibSQL = async (
|
|
left: SqliteSchema,
|
|
right: SqliteSchema,
|
|
renamesArr: string[],
|
|
cli: boolean = false,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
const leftTables = Object.values(left).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const leftViews = Object.values(left).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
|
|
|
|
const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
|
|
|
|
const serialized1 = generateSqliteSnapshot(leftTables, leftViews, casing);
|
|
const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
|
|
|
|
const { version: v1, dialect: d1, ...rest1 } = serialized1;
|
|
const { version: v2, dialect: d2, ...rest2 } = serialized2;
|
|
|
|
const sch1 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest1,
|
|
} as const;
|
|
|
|
const sch2 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn1 = squashSqliteScheme(sch1);
|
|
const sn2 = squashSqliteScheme(sch2);
|
|
|
|
const renames = new Set(renamesArr);
|
|
|
|
if (!cli) {
|
|
const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
testTablesResolver(renames),
|
|
testColumnsResolver(renames),
|
|
testViewsResolverSqlite(renames),
|
|
sch1,
|
|
sch2,
|
|
);
|
|
return { sqlStatements, statements };
|
|
}
|
|
|
|
const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
|
|
sn1,
|
|
sn2,
|
|
tablesResolver,
|
|
columnsResolver,
|
|
sqliteViewsResolver,
|
|
sch1,
|
|
sch2,
|
|
);
|
|
return { sqlStatements, statements };
|
|
};
|
|
|
|
// --- Introspect to file helpers ---
|
|
|
|
export const introspectPgToFile = async (
|
|
client: PGlite,
|
|
initSchema: PostgresSchema,
|
|
testName: string,
|
|
schemas: string[] = ['public'],
|
|
entities?: Entities,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
// put in db
|
|
const { sqlStatements } = await applyPgDiffs(initSchema, casing);
|
|
for (const st of sqlStatements) {
|
|
await client.query(st);
|
|
}
|
|
|
|
// introspect to schema
|
|
const introspectedSchema = await fromDatabase(
|
|
{
|
|
query: async (query: string, values?: any[] | undefined) => {
|
|
const res = await client.query(query, values);
|
|
return res.rows as any[];
|
|
},
|
|
},
|
|
undefined,
|
|
schemas,
|
|
entities,
|
|
);
|
|
|
|
const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
|
|
|
|
const initSch = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...initRest,
|
|
} as const;
|
|
|
|
const initSn = squashPgScheme(initSch);
|
|
const validatedCur = pgSchema.parse(initSch);
|
|
|
|
// write to ts file
|
|
const file = schemaToTypeScript(introspectedSchema, 'camel');
|
|
|
|
fs.writeFileSync(`tests/introspect/postgres/${testName}.ts`, file.file);
|
|
|
|
// generate snapshot from ts file
|
|
const response = await prepareFromPgImports([
|
|
`tests/introspect/postgres/${testName}.ts`,
|
|
]);
|
|
|
|
const afterFileImports = generatePgSnapshot(
|
|
response.tables,
|
|
response.enums,
|
|
response.schemas,
|
|
response.sequences,
|
|
response.roles,
|
|
response.policies,
|
|
response.views,
|
|
response.matViews,
|
|
casing,
|
|
);
|
|
|
|
const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
|
|
|
|
const sch2 = {
|
|
version: '7',
|
|
dialect: 'postgresql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn2AfterIm = squashPgScheme(sch2);
|
|
const validatedCurAfterImport = pgSchema.parse(sch2);
|
|
|
|
const {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
} = await applyPgSnapshotsDiff(
|
|
initSn,
|
|
sn2AfterIm,
|
|
testSchemasResolver(new Set()),
|
|
testEnumsResolver(new Set()),
|
|
testSequencesResolver(new Set()),
|
|
testPolicyResolver(new Set()),
|
|
testIndPolicyResolver(new Set()),
|
|
testRolesResolver(new Set()),
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolver(new Set()),
|
|
validatedCur,
|
|
validatedCurAfterImport,
|
|
);
|
|
|
|
fs.rmSync(`tests/introspect/postgres/${testName}.ts`);
|
|
|
|
return {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
};
|
|
};
|
|
|
|
export const introspectGelToFile = async (
|
|
client: GelClient,
|
|
testName: string,
|
|
schemas: string[] = ['public'],
|
|
entities?: Entities,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
// introspect to schema
|
|
const introspectedSchema = await fromGelDatabase(
|
|
{
|
|
query: async (query: string, values?: any[] | undefined) => {
|
|
const res = await client.querySQL(query, values);
|
|
return res as any[];
|
|
},
|
|
},
|
|
undefined,
|
|
schemas,
|
|
entities,
|
|
);
|
|
|
|
// write to ts file
|
|
const file = schemaToTypeScriptGel(introspectedSchema, 'camel');
|
|
|
|
const path = `tests/introspect/gel/${testName}.ts`;
|
|
fs.writeFileSync(path, file.file);
|
|
|
|
return path;
|
|
};
|
|
|
|
export const introspectMySQLToFile = async (
|
|
client: Connection,
|
|
initSchema: MysqlSchema,
|
|
testName: string,
|
|
schema: string,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
// put in db
|
|
const { sqlStatements } = await applyMySqlDiffs(initSchema, casing);
|
|
for (const st of sqlStatements) {
|
|
await client.query(st);
|
|
}
|
|
|
|
// introspect to schema
|
|
const introspectedSchema = await fromMySqlDatabase(
|
|
{
|
|
query: async (sql: string, params?: any[] | undefined) => {
|
|
const res = await client.execute(sql, params);
|
|
return res[0] as any;
|
|
},
|
|
},
|
|
schema,
|
|
);
|
|
|
|
const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
|
|
|
|
const initSch = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...initRest,
|
|
} as const;
|
|
|
|
const initSn = squashMysqlScheme(initSch);
|
|
const validatedCur = mysqlSchema.parse(initSch);
|
|
|
|
const file = schemaToTypeScriptMySQL(introspectedSchema, 'camel');
|
|
|
|
fs.writeFileSync(`tests/introspect/mysql/${testName}.ts`, file.file);
|
|
|
|
const response = await prepareFromMySqlImports([
|
|
`tests/introspect/mysql/${testName}.ts`,
|
|
]);
|
|
|
|
const afterFileImports = generateMySqlSnapshot(
|
|
response.tables,
|
|
response.views,
|
|
casing,
|
|
);
|
|
|
|
const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
|
|
|
|
const sch2 = {
|
|
version: '5',
|
|
dialect: 'mysql',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn2AfterIm = squashMysqlScheme(sch2);
|
|
const validatedCurAfterImport = mysqlSchema.parse(sch2);
|
|
|
|
const {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
} = await applyMysqlSnapshotsDiff(
|
|
sn2AfterIm,
|
|
initSn,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolverMySql(new Set()),
|
|
validatedCurAfterImport,
|
|
validatedCur,
|
|
);
|
|
|
|
fs.rmSync(`tests/introspect/mysql/${testName}.ts`);
|
|
|
|
return {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
};
|
|
};
|
|
|
|
export const introspectSingleStoreToFile = async (
|
|
client: Connection,
|
|
initSchema: SinglestoreSchema,
|
|
testName: string,
|
|
schema: string,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
// put in db
|
|
const { sqlStatements } = await applySingleStoreDiffs(initSchema, casing);
|
|
for (const st of sqlStatements) {
|
|
await client.query(st);
|
|
}
|
|
|
|
// introspect to schema
|
|
const introspectedSchema = await fromSingleStoreDatabase(
|
|
{
|
|
query: async (sql: string, params?: any[] | undefined) => {
|
|
const res = await client.execute(sql, params);
|
|
return res[0] as any;
|
|
},
|
|
},
|
|
schema,
|
|
);
|
|
|
|
const file = schemaToTypeScriptSingleStore(introspectedSchema, 'camel');
|
|
|
|
fs.writeFileSync(`tests/introspect/singlestore/${testName}.ts`, file.file);
|
|
|
|
const response = await prepareFromSingleStoreImports([
|
|
`tests/introspect/singlestore/${testName}.ts`,
|
|
]);
|
|
|
|
const afterFileImports = generateSingleStoreSnapshot(
|
|
response.tables,
|
|
/* response.views, */
|
|
casing,
|
|
);
|
|
|
|
const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
|
|
|
|
const sch2 = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn2AfterIm = squashSingleStoreScheme(sch2);
|
|
const validatedCurAfterImport = singlestoreSchema.parse(sch2);
|
|
|
|
const leftTables = Object.values(initSchema).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
|
|
|
|
const initSnapshot = generateSingleStoreSnapshot(
|
|
leftTables,
|
|
/* response.views, */
|
|
casing,
|
|
);
|
|
|
|
const { version: initV, dialect: initD, ...initRest } = initSnapshot;
|
|
|
|
const initSch = {
|
|
version: '1',
|
|
dialect: 'singlestore',
|
|
id: '0',
|
|
prevId: '0',
|
|
...initRest,
|
|
} as const;
|
|
|
|
const initSn = squashSingleStoreScheme(initSch);
|
|
const validatedCur = singlestoreSchema.parse(initSch);
|
|
|
|
const {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
} = await applySingleStoreSnapshotsDiff(
|
|
sn2AfterIm,
|
|
initSn,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
/* testViewsResolverSingleStore(new Set()), */
|
|
validatedCurAfterImport,
|
|
validatedCur,
|
|
);
|
|
|
|
fs.rmSync(`tests/introspect/singlestore/${testName}.ts`);
|
|
|
|
return {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
};
|
|
};
|
|
|
|
export const introspectSQLiteToFile = async (
|
|
client: Database,
|
|
initSchema: SqliteSchema,
|
|
testName: string,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
// put in db
|
|
const { sqlStatements } = await applySqliteDiffs(initSchema);
|
|
for (const st of sqlStatements) {
|
|
client.exec(st);
|
|
}
|
|
|
|
// introspect to schema
|
|
const introspectedSchema = await fromSqliteDatabase(
|
|
{
|
|
query: async <T>(sql: string, params: any[] = []) => {
|
|
return client.prepare(sql).bind(params).all() as T[];
|
|
},
|
|
run: async (query: string) => {
|
|
client.prepare(query).run();
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
|
|
const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
|
|
|
|
const initSch = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...initRest,
|
|
} as const;
|
|
|
|
const initSn = squashSqliteScheme(initSch);
|
|
|
|
const validatedCur = sqliteSchema.parse(initSch);
|
|
|
|
const file = schemaToTypeScriptSQLite(introspectedSchema, 'camel');
|
|
|
|
fs.writeFileSync(`tests/introspect/sqlite/${testName}.ts`, file.file);
|
|
|
|
const response = await prepareFromSqliteImports([
|
|
`tests/introspect/sqlite/${testName}.ts`,
|
|
]);
|
|
|
|
const afterFileImports = generateSqliteSnapshot(
|
|
response.tables,
|
|
response.views,
|
|
casing,
|
|
);
|
|
|
|
const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
|
|
|
|
const sch2 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn2AfterIm = squashSqliteScheme(sch2);
|
|
const validatedCurAfterImport = sqliteSchema.parse(sch2);
|
|
|
|
const {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
} = await applySqliteSnapshotsDiff(
|
|
sn2AfterIm,
|
|
initSn,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolverSqlite(new Set()),
|
|
validatedCurAfterImport,
|
|
validatedCur,
|
|
);
|
|
|
|
fs.rmSync(`tests/introspect/sqlite/${testName}.ts`);
|
|
|
|
return {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
};
|
|
};
|
|
|
|
export const introspectLibSQLToFile = async (
|
|
client: Client,
|
|
initSchema: SqliteSchema,
|
|
testName: string,
|
|
casing?: CasingType | undefined,
|
|
) => {
|
|
// put in db
|
|
const { sqlStatements } = await applyLibSQLDiffs(initSchema);
|
|
for (const st of sqlStatements) {
|
|
client.execute(st);
|
|
}
|
|
|
|
// introspect to schema
|
|
const introspectedSchema = await fromSqliteDatabase(
|
|
{
|
|
query: async <T>(sql: string, params: any[] = []) => {
|
|
return (await client.execute({ sql, args: params })).rows as T[];
|
|
},
|
|
run: async (query: string) => {
|
|
client.execute(query);
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
|
|
const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
|
|
|
|
const initSch = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...initRest,
|
|
} as const;
|
|
|
|
const initSn = squashSqliteScheme(initSch);
|
|
|
|
const validatedCur = sqliteSchema.parse(initSch);
|
|
|
|
const file = schemaToTypeScriptSQLite(introspectedSchema, 'camel');
|
|
|
|
fs.writeFileSync(`tests/introspect/libsql/${testName}.ts`, file.file);
|
|
|
|
const response = await prepareFromSqliteImports([
|
|
`tests/introspect/libsql/${testName}.ts`,
|
|
]);
|
|
|
|
const afterFileImports = generateSqliteSnapshot(
|
|
response.tables,
|
|
response.views,
|
|
casing,
|
|
);
|
|
|
|
const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
|
|
|
|
const sch2 = {
|
|
version: '6',
|
|
dialect: 'sqlite',
|
|
id: '0',
|
|
prevId: '0',
|
|
...rest2,
|
|
} as const;
|
|
|
|
const sn2AfterIm = squashSqliteScheme(sch2);
|
|
const validatedCurAfterImport = sqliteSchema.parse(sch2);
|
|
|
|
const {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
} = await applyLibSQLSnapshotsDiff(
|
|
sn2AfterIm,
|
|
initSn,
|
|
testTablesResolver(new Set()),
|
|
testColumnsResolver(new Set()),
|
|
testViewsResolverSqlite(new Set()),
|
|
validatedCurAfterImport,
|
|
validatedCur,
|
|
);
|
|
|
|
fs.rmSync(`tests/introspect/libsql/${testName}.ts`);
|
|
|
|
return {
|
|
sqlStatements: afterFileSqlStatements,
|
|
statements: afterFileStatements,
|
|
};
|
|
};
|