github-mirrors/immich
1
0
Fork 0
mirror of https://github.com/immich-app/immich.git synced 2026-05-18 03:10:24 +03:00
Code Issues Packages Projects Releases Wiki Activity

chore: migrate to sql-tools library (#26400)

Browse Source 
Co-authored-by: Jason Rasmussen <jason@rasm.me>
This commit is contained in:
Daniel Dietzler
2026-02-23 15:50:16 +01:00
committed by GitHub
parent a469d350be
commit a07d7b0c82
231 changed files with 209 additions and 9151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/test/sql-tools/check-constraint-default-name.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { Check, Column, ConstraintType, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
@Check({ expression: '1=1' })
export class Table1 {
@Column({ type: 'uuid' })
id!: string;
}
export const description = 'should create a check constraint with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.CHECK,
name: 'CHK_8d2ecfd49b984941f6b2589799',
tableName: 'table1',
expression: '1=1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/check-constraint-override-name.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { Check, Column, ConstraintType, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
@Check({ name: 'CHK_test', expression: '1=1' })
export class Table1 {
@Column({ type: 'uuid' })
id!: string;
}
export const description = 'should create a check constraint with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.CHECK,
name: 'CHK_test',
tableName: 'table1',
expression: '1=1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-create-date.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { CreateDateColumn, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@CreateDateColumn()
createdAt!: string;
}
export const description = 'should register a table with an created at date column';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'createdAt',
tableName: 'table1',
type: 'timestamp with time zone',
default: 'now()',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-array.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'character varying', array: true, default: [] })
column1!: string[];
}
export const description = 'should register a table with a column with a default value (array)';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: true,
primary: false,
synchronize: true,
default: "'{}'",
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-boolean.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'boolean', default: true })
column1!: boolean;
}
export const description = 'should register a table with a column with a default value (boolean)';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'boolean',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
default: 'true',
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-date.stub.ts
-42
View File
@@ -1,42 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
const date = new Date(2023, 0, 1);
@Table()
export class Table1 {
@Column({ type: 'character varying', default: date })
column1!: string;
}
export const description = 'should register a table with a column with a default value (date)';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
default: "'2023-01-01T00:00:00.000Z'",
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-function.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'character varying', default: () => 'now()' })
column1!: string;
}
export const description = 'should register a table with a column with a default function';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
default: 'now()',
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-null.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'character varying', default: null })
column1!: string;
}
export const description = 'should register a nullable column from a default of null';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: true,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-number.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'integer', default: 0 })
column1!: string;
}
export const description = 'should register a table with a column with a default value (number)';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'integer',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
default: '0',
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-default-string.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'character varying', default: 'foo' })
column1!: string;
}
export const description = 'should register a table with a column with a default value (string)';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
default: "'foo'",
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-delete-date.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { DatabaseSchema, DeleteDateColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@DeleteDateColumn()
deletedAt!: string;
}
export const description = 'should register a table with a deleted at date column';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'deletedAt',
tableName: 'table1',
type: 'timestamp with time zone',
nullable: true,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-enum-type.stub.ts
-53
View File
@@ -1,53 +0,0 @@
import { Column, DatabaseSchema, registerEnum, Table } from 'src/sql-tools';
enum Test {
Foo = 'foo',
Bar = 'bar',
}
const test_enum = registerEnum({ name: 'test_enum', values: Object.values(Test) });
@Table()
export class Table1 {
@Column({ enum: test_enum })
column1!: string;
}
export const description = 'should accept an enum type';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [
{
name: 'test_enum',
values: ['foo', 'bar'],
synchronize: true,
},
],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'enum',
enumName: 'test_enum',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-generated-identity.ts
-48
View File
@@ -1,48 +0,0 @@
import { ConstraintType, DatabaseSchema, PrimaryGeneratedColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryGeneratedColumn({ strategy: 'identity' })
column1!: string;
}
export const description = 'should register a table with a generated identity column';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'integer',
identity: true,
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_50c4f9905061b1e506d38a2a380',
tableName: 'table1',
columnNames: ['column1'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-generated-uuid.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { ConstraintType, DatabaseSchema, PrimaryGeneratedColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryGeneratedColumn({ strategy: 'uuid' })
column1!: string;
}
export const description = 'should register a table with a primary generated uuid column';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'uuid',
default: 'uuid_generate_v4()',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_50c4f9905061b1e506d38a2a380',
tableName: 'table1',
columnNames: ['column1'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-index-name-default.ts
-47
View File
@@ -1,47 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ index: true })
column1!: string;
}
export const description = 'should create a column with an index';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_50c4f9905061b1e506d38a2a38',
columnNames: ['column1'],
tableName: 'table1',
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-index-name.ts
-47
View File
@@ -1,47 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ indexName: 'IDX_test' })
column1!: string;
}
export const description = 'should create a column with an index if a name is provided';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_test',
columnNames: ['column1'],
tableName: 'table1',
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-inferred-nullable.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ default: null })
column1!: string;
}
export const description = 'should infer nullable from the default value';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: true,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-name-default.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column()
column1!: string;
}
export const description = 'should register a table with a column with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-name-override.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ name: 'column-1' })
column1!: string;
}
export const description = 'should register a table with a column with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column-1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-name-string.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column('column-1')
column1!: string;
}
export const description = 'should register a table with a column with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column-1',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-nullable.stub.ts
-39
View File
@@ -1,39 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ nullable: true })
column1!: string;
}
export const description = 'should set nullable correctly';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: true,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-string-length.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { Column, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ length: 2 })
column1!: string;
}
export const description = 'should use create a string column with a fixed length';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
length: 2,
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-unique-constraint-name-default.stub.ts
-47
View File
@@ -1,47 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'uuid', unique: true })
id!: string;
}
export const description = 'should create a unique key constraint with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.UNIQUE,
name: 'UQ_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-unique-constraint-name-override.stub.ts
-47
View File
@@ -1,47 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column({ type: 'uuid', unique: true, uniqueConstraintName: 'UQ_test' })
id!: string;
}
export const description = 'should create a unique key constraint with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.UNIQUE,
name: 'UQ_test',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/column-update-date.stub.ts
-40
View File
@@ -1,40 +0,0 @@
import { DatabaseSchema, Table, UpdateDateColumn } from 'src/sql-tools';
@Table()
export class Table1 {
@UpdateDateColumn()
updatedAt!: string;
}
export const description = 'should register a table with an updated at date column';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'updatedAt',
tableName: 'table1',
type: 'timestamp with time zone',
default: 'now()',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/errors/table-duplicate-decorator.stub.ts
-7
View File
@@ -1,7 +0,0 @@
import { Table } from 'src/sql-tools';
@Table({ name: 'table-1' })
@Table({ name: 'table-2' })
export class Table1 {}
export const message = 'Table table-2 has already been registered';
server/test/sql-tools/foreign-key-constraint-column-order.stub.ts
-118
View File
@@ -1,118 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id1!: string;
@PrimaryColumn({ type: 'uuid' })
id2!: string;
}
@Table()
@ForeignKeyConstraint({
columns: ['parentId1', 'parentId2'],
referenceTable: () => Table1,
referenceColumns: ['id2', 'id1'],
})
export class Table2 {
@Column({ type: 'uuid' })
parentId1!: string;
@Column({ type: 'uuid' })
parentId2!: string;
}
export const description = 'should create a foreign key constraint to the target table';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id1',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
{
name: 'id2',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_e457e8b1301b7bc06ef78188ee4',
tableName: 'table1',
columnNames: ['id1', 'id2'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId1',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
{
name: 'parentId2',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_aed36d04470eba20161aa8b1dc',
tableName: 'table2',
columnNames: ['parentId1', 'parentId2'],
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_aed36d04470eba20161aa8b1dc6',
tableName: 'table2',
columnNames: ['parentId1', 'parentId2'],
referenceColumnNames: ['id2', 'id1'],
referenceTableName: 'table1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/foreign-key-constraint-missing-column.stub.ts
-72
View File
@@ -1,72 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
@Table()
@ForeignKeyConstraint({ columns: ['parentId2'], referenceTable: () => Table1 })
export class Table2 {
@Column({ type: 'uuid' })
parentId!: string;
}
export const description = 'should warn against missing column in foreign key constraint';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: ['[@ForeignKeyConstraint.columns] Unable to find column (Table2.parentId2)'],
};
server/test/sql-tools/foreign-key-constraint-missing-reference-column.stub.ts
-72
View File
@@ -1,72 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
@Table()
@ForeignKeyConstraint({ columns: ['parentId'], referenceTable: () => Table1, referenceColumns: ['foo'] })
export class Table2 {
@Column({ type: 'uuid' })
parentId!: string;
}
export const description = 'should warn against missing reference column in foreign key constraint';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: ['[@ForeignKeyConstraint.referenceColumns] Unable to find column (Table1.foo)'],
};
server/test/sql-tools/foreign-key-constraint-missing-reference-table.stub.ts
-45
View File
@@ -1,45 +0,0 @@
import { Column, DatabaseSchema, ForeignKeyConstraint, Table } from 'src/sql-tools';
class Foo {}
@Table()
@ForeignKeyConstraint({
columns: ['parentId'],
referenceTable: () => Foo,
})
export class Table1 {
@Column()
parentId!: string;
}
export const description = 'should warn against missing reference table';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'parentId',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: ['[@ForeignKeyConstraint.referenceTable] Unable to find table (Foo)'],
};
server/test/sql-tools/foreign-key-constraint-multiple-columns.stub.ts
-114
View File
@@ -1,114 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id1!: string;
@PrimaryColumn({ type: 'uuid' })
id2!: string;
}
@Table()
@ForeignKeyConstraint({ columns: ['parentId1', 'parentId2'], referenceTable: () => Table1 })
export class Table2 {
@Column({ type: 'uuid' })
parentId1!: string;
@Column({ type: 'uuid' })
parentId2!: string;
}
export const description = 'should create a foreign key constraint to the target table';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id1',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
{
name: 'id2',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_e457e8b1301b7bc06ef78188ee4',
tableName: 'table1',
columnNames: ['id1', 'id2'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId1',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
{
name: 'parentId2',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_aed36d04470eba20161aa8b1dc',
tableName: 'table2',
columnNames: ['parentId1', 'parentId2'],
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_aed36d04470eba20161aa8b1dc6',
tableName: 'table2',
columnNames: ['parentId1', 'parentId2'],
referenceColumnNames: ['id1', 'id2'],
referenceTableName: 'table1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/foreign-key-constraint-no-index.stub.ts
-82
View File
@@ -1,82 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
@Table()
@ForeignKeyConstraint({ columns: ['parentId'], referenceTable: () => Table1, index: false })
export class Table2 {
@Column({ type: 'uuid' })
parentId!: string;
}
export const description = 'should create a foreign key constraint to the target table without an index';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_3fcca5cc563abf256fc346e3ff4',
tableName: 'table2',
columnNames: ['parentId'],
referenceColumnNames: ['id'],
referenceTableName: 'table1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/foreign-key-constraint-no-primary.stub.ts
-86
View File
@@ -1,86 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@Column()
foo!: string;
}
@Table()
@ForeignKeyConstraint({
columns: ['bar'],
referenceTable: () => Table1,
referenceColumns: ['foo'],
})
export class Table2 {
@Column()
bar!: string;
}
export const description = 'should create a foreign key constraint to the target table without a primary key';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'foo',
tableName: 'table1',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'bar',
tableName: 'table2',
type: 'character varying',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_7d9c784c98d12365d198d52e4e',
tableName: 'table2',
columnNames: ['bar'],
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_7d9c784c98d12365d198d52e4e6',
tableName: 'table2',
columnNames: ['bar'],
referenceTableName: 'table1',
referenceColumnNames: ['foo'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/foreign-key-constraint.stub.ts
-90
View File
@@ -1,90 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, ForeignKeyConstraint, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
@Table()
@ForeignKeyConstraint({ columns: ['parentId'], referenceTable: () => Table1 })
export class Table2 {
@Column({ type: 'uuid' })
parentId!: string;
}
export const description = 'should create a foreign key constraint to the target table';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_3fcca5cc563abf256fc346e3ff',
tableName: 'table2',
columnNames: ['parentId'],
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_3fcca5cc563abf256fc346e3ff4',
tableName: 'table2',
columnNames: ['parentId'],
referenceColumnNames: ['id'],
referenceTableName: 'table1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/foreign-key-inferred-type.stub.ts
-89
View File
@@ -1,89 +0,0 @@
import { ConstraintType, DatabaseSchema, ForeignKeyColumn, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
@Table()
export class Table2 {
@ForeignKeyColumn(() => Table1, {})
parentId!: string;
}
export const description = 'should infer the column type from the reference column';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_3fcca5cc563abf256fc346e3ff',
tableName: 'table2',
columnNames: ['parentId'],
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_3fcca5cc563abf256fc346e3ff4',
tableName: 'table2',
columnNames: ['parentId'],
referenceColumnNames: ['id'],
referenceTableName: 'table1',
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/foreign-key-with-unique-constraint.stub.ts
-96
View File
@@ -1,96 +0,0 @@
import { ConstraintType, DatabaseSchema, ForeignKeyColumn, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
@Table()
export class Table2 {
@ForeignKeyColumn(() => Table1, { unique: true })
parentId!: string;
}
export const description = 'should create a foreign key constraint with a unique constraint';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
{
name: 'table2',
columns: [
{
name: 'parentId',
tableName: 'table2',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_3fcca5cc563abf256fc346e3ff',
tableName: 'table2',
columnNames: ['parentId'],
unique: false,
synchronize: true,
},
],
triggers: [],
constraints: [
{
type: ConstraintType.FOREIGN_KEY,
name: 'FK_3fcca5cc563abf256fc346e3ff4',
tableName: 'table2',
columnNames: ['parentId'],
referenceColumnNames: ['id'],
referenceTableName: 'table1',
synchronize: true,
},
{
type: ConstraintType.UNIQUE,
name: 'UQ_3fcca5cc563abf256fc346e3ff4',
tableName: 'table2',
columnNames: ['parentId'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/index-name-default.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { Column, DatabaseSchema, Index, Table } from 'src/sql-tools';
@Table()
@Index({ columns: ['id'] })
export class Table1 {
@Column({ type: 'uuid' })
id!: string;
}
export const description = 'should create an index with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_b249cc64cf63b8a22557cdc853',
tableName: 'table1',
unique: false,
columnNames: ['id'],
synchronize: true,
},
],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/index-name-override.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { Column, DatabaseSchema, Index, Table } from 'src/sql-tools';
@Table()
@Index({ name: 'IDX_test', columns: ['id'] })
export class Table1 {
@Column({ type: 'uuid' })
id!: string;
}
export const description = 'should create an index with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_test',
tableName: 'table1',
unique: false,
columnNames: ['id'],
synchronize: true,
},
],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/index-with-expression.ts
-48
View File
@@ -1,48 +0,0 @@
import { Column, DatabaseSchema, Index, Table } from 'src/sql-tools';
@Table()
@Index({ expression: '"id" IS NOT NULL' })
export class Table1 {
@Column({ nullable: true })
column1!: string;
}
export const description = 'should create an index based off of an expression';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: true,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_376788d186160c4faa5aaaef63',
tableName: 'table1',
unique: false,
expression: '"id" IS NOT NULL',
synchronize: true,
},
],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/index-with-where.stub.ts
-49
View File
@@ -1,49 +0,0 @@
import { Column, DatabaseSchema, Index, Table } from 'src/sql-tools';
@Table()
@Index({ columns: ['id'], where: '"id" IS NOT NULL' })
export class Table1 {
@Column({ nullable: true })
column1!: string;
}
export const description = 'should create an index with a where clause';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'column1',
tableName: 'table1',
type: 'character varying',
nullable: true,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [
{
name: 'IDX_9f4e073964c0395f51f9b39900',
tableName: 'table1',
unique: false,
columnNames: ['id'],
where: '"id" IS NOT NULL',
synchronize: true,
},
],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/primary-key-constraint-name-default.stub.ts
-47
View File
@@ -1,47 +0,0 @@
import { ConstraintType, DatabaseSchema, PrimaryColumn, Table } from 'src/sql-tools';
@Table()
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
export const description = 'should add a primary key constraint to the table with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/primary-key-constraint-name-override.stub.ts
-47
View File
@@ -1,47 +0,0 @@
import { ConstraintType, DatabaseSchema, PrimaryColumn, Table } from 'src/sql-tools';
@Table({ primaryConstraintName: 'PK_test' })
export class Table1 {
@PrimaryColumn({ type: 'uuid' })
id!: string;
}
export const description = 'should add a primary key constraint to the table with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: true,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.PRIMARY_KEY,
name: 'PK_test',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/table-name-default.stub.ts
-26
View File
@@ -1,26 +0,0 @@
import { DatabaseSchema, Table } from 'src/sql-tools';
@Table()
export class Table1 {}
export const description = 'should register a table with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/table-name-override.stub.ts
-26
View File
@@ -1,26 +0,0 @@
import { DatabaseSchema, Table } from 'src/sql-tools';
@Table({ name: 'table-1' })
export class Table1 {}
export const description = 'should register a table with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table-1',
columns: [],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/table-name-string-option.stub.ts
-26
View File
@@ -1,26 +0,0 @@
import { DatabaseSchema, Table } from 'src/sql-tools';
@Table('table-1')
export class Table1 {}
export const description = 'should register a table with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table-1',
columns: [],
indexes: [],
triggers: [],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/trigger-after-delete.stub.ts
-47
View File
@@ -1,47 +0,0 @@
import { AfterDeleteTrigger, DatabaseSchema, registerFunction, Table } from 'src/sql-tools';
const test_fn = registerFunction({
name: 'test_fn',
body: 'SELECT 1;',
returnType: 'character varying',
});
@Table()
@AfterDeleteTrigger({
name: 'my_trigger',
function: test_fn,
scope: 'row',
})
export class Table1 {}
export const description = 'should create a trigger';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [expect.any(Object)],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [],
indexes: [],
triggers: [
{
name: 'my_trigger',
functionName: 'test_fn',
tableName: 'table1',
timing: 'after',
scope: 'row',
actions: ['delete'],
synchronize: true,
},
],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/trigger-before-update.stub.ts
-47
View File
@@ -1,47 +0,0 @@
import { BeforeUpdateTrigger, DatabaseSchema, registerFunction, Table } from 'src/sql-tools';
const test_fn = registerFunction({
name: 'test_fn',
body: 'SELECT 1;',
returnType: 'character varying',
});
@Table()
@BeforeUpdateTrigger({
name: 'my_trigger',
function: test_fn,
scope: 'row',
})
export class Table1 {}
export const description = 'should create a trigger ';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [expect.any(Object)],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [],
indexes: [],
triggers: [
{
name: 'my_trigger',
functionName: 'test_fn',
tableName: 'table1',
timing: 'before',
scope: 'row',
actions: ['update'],
synchronize: true,
},
],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/trigger-name-default.stub.ts
-42
View File
@@ -1,42 +0,0 @@
import { DatabaseSchema, Table, Trigger } from 'src/sql-tools';
@Table()
@Trigger({
timing: 'before',
actions: ['insert'],
scope: 'row',
functionName: 'function1',
})
export class Table1 {}
export const description = 'should register a trigger with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [],
indexes: [],
triggers: [
{
name: 'TR_ca71832b10b77ed600ef05df631',
tableName: 'table1',
functionName: 'function1',
actions: ['insert'],
scope: 'row',
timing: 'before',
synchronize: true,
},
],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/trigger-name-override.stub.ts
-43
View File
@@ -1,43 +0,0 @@
import { DatabaseSchema, Table, Trigger } from 'src/sql-tools';
@Table()
@Trigger({
name: 'trigger1',
timing: 'before',
actions: ['insert'],
scope: 'row',
functionName: 'function1',
})
export class Table1 {}
export const description = 'should a trigger with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [],
indexes: [],
triggers: [
{
name: 'trigger1',
tableName: 'table1',
functionName: 'function1',
actions: ['insert'],
scope: 'row',
timing: 'before',
synchronize: true,
},
],
constraints: [],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/unique-constraint-name-default.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, Table, Unique } from 'src/sql-tools';
@Table()
@Unique({ columns: ['id'] })
export class Table1 {
@Column({ type: 'uuid' })
id!: string;
}
export const description = 'should add a unique constraint to the table with a default name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.UNIQUE,
name: 'UQ_b249cc64cf63b8a22557cdc8537',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/sql-tools/unique-constraint-name-override.stub.ts
-48
View File
@@ -1,48 +0,0 @@
import { Column, ConstraintType, DatabaseSchema, Table, Unique } from 'src/sql-tools';
@Table()
@Unique({ name: 'UQ_test', columns: ['id'] })
export class Table1 {
@Column({ type: 'uuid' })
id!: string;
}
export const description = 'should add a unique constraint to the table with a specific name';
export const schema: DatabaseSchema = {
databaseName: 'postgres',
schemaName: 'public',
functions: [],
enums: [],
extensions: [],
parameters: [],
overrides: [],
tables: [
{
name: 'table1',
columns: [
{
name: 'id',
tableName: 'table1',
type: 'uuid',
nullable: false,
isArray: false,
primary: false,
synchronize: true,
},
],
indexes: [],
triggers: [],
constraints: [
{
type: ConstraintType.UNIQUE,
name: 'UQ_test',
tableName: 'table1',
columnNames: ['id'],
synchronize: true,
},
],
synchronize: true,
},
],
warnings: [],
};
server/test/utils.ts
+4 -9
View File
@@ -1,3 +1,4 @@
import { createPostgres, DatabaseConnectionParams } from '@immich/sql-tools';
import { CallHandler, ExecutionContext, Provider, ValidationPipe } from '@nestjs/common';
import { APP_GUARD, APP_PIPE } from '@nestjs/core';
import { transformException } from '@nestjs/platform-express/multer/multer/multer.utils';
@@ -9,7 +10,6 @@ import multer from 'multer';
import { ChildProcessWithoutNullStreams } from 'node:child_process';
import { Duplex, Readable, Writable } from 'node:stream';
import { PNG } from 'pngjs';
import postgres from 'postgres';
import { UploadFieldName } from 'src/dtos/asset-media.dto';
import { AssetUploadInterceptor } from 'src/middleware/asset-upload.interceptor';
import { AuthGuard } from 'src/middleware/auth.guard';
@@ -70,7 +70,7 @@ import { DB } from 'src/schema';
import { AuthService } from 'src/services/auth.service';
import { BaseService } from 'src/services/base.service';
import { RepositoryInterface } from 'src/types';
import { asPostgresConnectionConfig, getKyselyConfig } from 'src/utils/database';
import { getKyselyConfig } from 'src/utils/database';
import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
import { newConfigRepositoryMock } from 'test/repositories/config.repository.mock';
@@ -445,13 +445,8 @@ const withDatabase = (url: string, name: string) => url.replace(`/${templateName
export const getKyselyDB = async (suffix?: string): Promise<Kysely<DB>> => {
const testUrl = process.env.IMMICH_TEST_POSTGRES_URL!;
const sql = postgres({
...asPostgresConnectionConfig({
connectionType: 'url',
url: withDatabase(testUrl, 'postgres'),
}),
max: 1,
});
const connection = { connectionType: 'url', url: withDatabase(testUrl, 'postgres') } as DatabaseConnectionParams;
const sql = createPostgres({ maxConnections: 1, connection });
const randomSuffix = Math.random().toString(36).slice(2, 7);
const dbName = `immich_${suffix ?? randomSuffix}`;