feat: schema-check (#25904)

server/src/sql-tools/comparers/column.comparer.spec.ts

@@ -15,7 +15,7 @@ const testColumn: DatabaseColumn = {
 describe('compareColumns', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareColumns.onExtra(testColumn)).toEqual([
+      expect(compareColumns().onExtra(testColumn)).toEqual([
         {
           tableName: 'table1',
           columnName: 'test',
@@ -28,7 +28,7 @@ describe('compareColumns', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareColumns.onMissing(testColumn)).toEqual([
+      expect(compareColumns().onMissing(testColumn)).toEqual([
         {
           type: 'ColumnAdd',
           column: testColumn,
@@ -40,14 +40,14 @@ describe('compareColumns', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareColumns.onCompare(testColumn, testColumn)).toEqual([]);
+      expect(compareColumns().onCompare(testColumn, testColumn)).toEqual([]);
     });
 
     it('should detect a change in type', () => {
       const source: DatabaseColumn = { ...testColumn };
       const target: DatabaseColumn = { ...testColumn, type: 'text' };
       const reason = 'column type is different (character varying vs text)';
-      expect(compareColumns.onCompare(source, target)).toEqual([
+      expect(compareColumns().onCompare(source, target)).toEqual([
         {
           columnName: 'test',
           tableName: 'table1',
@@ -66,7 +66,7 @@ describe('compareColumns', () => {
       const source: DatabaseColumn = { ...testColumn, nullable: true };
       const target: DatabaseColumn = { ...testColumn, nullable: true, default: "''" };
       const reason = `default is different (null vs '')`;
-      expect(compareColumns.onCompare(source, target)).toEqual([
+      expect(compareColumns().onCompare(source, target)).toEqual([
         {
           columnName: 'test',
           tableName: 'table1',
@@ -83,7 +83,7 @@ describe('compareColumns', () => {
       const source: DatabaseColumn = { ...testColumn, comment: 'new comment' };
       const target: DatabaseColumn = { ...testColumn, comment: 'old comment' };
       const reason = 'comment is different (new comment vs old comment)';
-      expect(compareColumns.onCompare(source, target)).toEqual([
+      expect(compareColumns().onCompare(source, target)).toEqual([
         {
           columnName: 'test',
           tableName: 'table1',

server/src/sql-tools/comparers/column.comparer.ts

@@ -1,98 +1,99 @@
 import { asRenameKey, getColumnType, isDefaultEqual } from 'src/sql-tools/helpers';
 import { Comparer, DatabaseColumn, Reason, SchemaDiff } from 'src/sql-tools/types';
 
-export const compareColumns = {
-  getRenameKey: (column) => {
-    return asRenameKey([
-      column.tableName,
-      column.type,
-      column.nullable,
-      column.default,
-      column.storage,
-      column.primary,
-      column.isArray,
-      column.length,
-      column.identity,
-      column.enumName,
-      column.numericPrecision,
-      column.numericScale,
-    ]);
-  },
-  onRename: (source, target) => [
-    {
-      type: 'ColumnRename',
-      tableName: source.tableName,
-      oldName: target.name,
-      newName: source.name,
-      reason: Reason.Rename,
+export const compareColumns = () =>
+  ({
+    getRenameKey: (column) => {
+      return asRenameKey([
+        column.tableName,
+        column.type,
+        column.nullable,
+        column.default,
+        column.storage,
+        column.primary,
+        column.isArray,
+        column.length,
+        column.identity,
+        column.enumName,
+        column.numericPrecision,
+        column.numericScale,
+      ]);
     },
-  ],
-  onMissing: (source) => [
-    {
-      type: 'ColumnAdd',
-      column: source,
-      reason: Reason.MissingInTarget,
+    onRename: (source, target) => [
+      {
+        type: 'ColumnRename',
+        tableName: source.tableName,
+        oldName: target.name,
+        newName: source.name,
+        reason: Reason.Rename,
+      },
+    ],
+    onMissing: (source) => [
+      {
+        type: 'ColumnAdd',
+        column: source,
+        reason: Reason.MissingInTarget,
+      },
+    ],
+    onExtra: (target) => [
+      {
+        type: 'ColumnDrop',
+        tableName: target.tableName,
+        columnName: target.name,
+        reason: Reason.MissingInSource,
+      },
+    ],
+    onCompare: (source, target) => {
+      const sourceType = getColumnType(source);
+      const targetType = getColumnType(target);
+
+      const isTypeChanged = sourceType !== targetType;
+
+      if (isTypeChanged) {
+        // TODO: convert between types via UPDATE when possible
+        return dropAndRecreateColumn(source, target, `column type is different (${sourceType} vs ${targetType})`);
+      }
+
+      const items: SchemaDiff[] = [];
+      if (source.nullable !== target.nullable) {
+        items.push({
+          type: 'ColumnAlter',
+          tableName: source.tableName,
+          columnName: source.name,
+          changes: {
+            nullable: source.nullable,
+          },
+          reason: `nullable is different (${source.nullable} vs ${target.nullable})`,
+        });
+      }
+
+      if (!isDefaultEqual(source, target)) {
+        items.push({
+          type: 'ColumnAlter',
+          tableName: source.tableName,
+          columnName: source.name,
+          changes: {
+            default: String(source.default ?? 'NULL'),
+          },
+          reason: `default is different (${source.default ?? 'null'} vs ${target.default})`,
+        });
+      }
+
+      if (source.comment !== target.comment) {
+        items.push({
+          type: 'ColumnAlter',
+          tableName: source.tableName,
+          columnName: source.name,
+          changes: {
+            comment: String(source.comment),
+          },
+          reason: `comment is different (${source.comment} vs ${target.comment})`,
+        });
+      }
+
+      return items;
     },
-  ],
-  onExtra: (target) => [
-    {
-      type: 'ColumnDrop',
-      tableName: target.tableName,
-      columnName: target.name,
-      reason: Reason.MissingInSource,
-    },
-  ],
-  onCompare: (source, target) => {
-    const sourceType = getColumnType(source);
-    const targetType = getColumnType(target);
-
-    const isTypeChanged = sourceType !== targetType;
-
-    if (isTypeChanged) {
-      // TODO: convert between types via UPDATE when possible
-      return dropAndRecreateColumn(source, target, `column type is different (${sourceType} vs ${targetType})`);
-    }
-
-    const items: SchemaDiff[] = [];
-    if (source.nullable !== target.nullable) {
-      items.push({
-        type: 'ColumnAlter',
-        tableName: source.tableName,
-        columnName: source.name,
-        changes: {
-          nullable: source.nullable,
-        },
-        reason: `nullable is different (${source.nullable} vs ${target.nullable})`,
-      });
-    }
-
-    if (!isDefaultEqual(source, target)) {
-      items.push({
-        type: 'ColumnAlter',
-        tableName: source.tableName,
-        columnName: source.name,
-        changes: {
-          default: String(source.default ?? 'NULL'),
-        },
-        reason: `default is different (${source.default ?? 'null'} vs ${target.default})`,
-      });
-    }
-
-    if (source.comment !== target.comment) {
-      items.push({
-        type: 'ColumnAlter',
-        tableName: source.tableName,
-        columnName: source.name,
-        changes: {
-          comment: String(source.comment),
-        },
-        reason: `comment is different (${source.comment} vs ${target.comment})`,
-      });
-    }
-
-    return items;
-  },
-} satisfies Comparer<DatabaseColumn>;
+  }) satisfies Comparer<DatabaseColumn>;
 
 const dropAndRecreateColumn = (source: DatabaseColumn, target: DatabaseColumn, reason: string): SchemaDiff[] => {
   return [

server/src/sql-tools/comparers/constraint.comparer.spec.ts

@@ -13,7 +13,7 @@ const testConstraint: DatabaseConstraint = {
 describe('compareConstraints', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareConstraints.onExtra(testConstraint)).toEqual([
+      expect(compareConstraints().onExtra(testConstraint)).toEqual([
         {
           type: 'ConstraintDrop',
           constraintName: 'test',
@@ -26,7 +26,7 @@ describe('compareConstraints', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareConstraints.onMissing(testConstraint)).toEqual([
+      expect(compareConstraints().onMissing(testConstraint)).toEqual([
         {
           type: 'ConstraintAdd',
           constraint: testConstraint,
@@ -38,14 +38,14 @@ describe('compareConstraints', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareConstraints.onCompare(testConstraint, testConstraint)).toEqual([]);
+      expect(compareConstraints().onCompare(testConstraint, testConstraint)).toEqual([]);
     });
 
     it('should detect a change in type', () => {
       const source: DatabaseConstraint = { ...testConstraint };
       const target: DatabaseConstraint = { ...testConstraint, columnNames: ['column1', 'column2'] };
       const reason = 'Primary key columns are different: (column1 vs column1,column2)';
-      expect(compareConstraints.onCompare(source, target)).toEqual([
+      expect(compareConstraints().onCompare(source, target)).toEqual([
         {
           constraintName: 'test',
           tableName: 'table1',

server/src/sql-tools/comparers/constraint.comparer.ts

@@ -12,7 +12,7 @@ import {
   SchemaDiff,
 } from 'src/sql-tools/types';
 
-export const compareConstraints: Comparer<DatabaseConstraint> = {
+export const compareConstraints = (): Comparer<DatabaseConstraint> => ({
   getRenameKey: (constraint) => {
     switch (constraint.type) {
       case ConstraintType.PRIMARY_KEY:
@@ -83,7 +83,7 @@ export const compareConstraints: Comparer<DatabaseConstraint> = {
       }
     }
   },
-};
+});
 
 const comparePrimaryKeyConstraint: CompareFunction<DatabasePrimaryKeyConstraint> = (source, target) => {
   if (!haveEqualColumns(source.columnNames, target.columnNames)) {

server/src/sql-tools/comparers/enum.comparer.spec.ts

@@ -7,7 +7,7 @@ const testEnum: DatabaseEnum = { name: 'test', values: ['foo', 'bar'], synchroni
 describe('compareEnums', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareEnums.onExtra(testEnum)).toEqual([
+      expect(compareEnums().onExtra(testEnum)).toEqual([
         {
           enumName: 'test',
           type: 'EnumDrop',
@@ -19,7 +19,7 @@ describe('compareEnums', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareEnums.onMissing(testEnum)).toEqual([
+      expect(compareEnums().onMissing(testEnum)).toEqual([
         {
           type: 'EnumCreate',
           enum: testEnum,
@@ -31,13 +31,13 @@ describe('compareEnums', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareEnums.onCompare(testEnum, testEnum)).toEqual([]);
+      expect(compareEnums().onCompare(testEnum, testEnum)).toEqual([]);
     });
 
     it('should drop and recreate when values list is different', () => {
       const source = { name: 'test', values: ['foo', 'bar'], synchronize: true };
       const target = { name: 'test', values: ['foo', 'bar', 'world'], synchronize: true };
-      expect(compareEnums.onCompare(source, target)).toEqual([
+      expect(compareEnums().onCompare(source, target)).toEqual([
         {
           enumName: 'test',
           type: 'EnumDrop',

server/src/sql-tools/comparers/enum.comparer.ts

@@ -1,6 +1,6 @@
 import { Comparer, DatabaseEnum, Reason } from 'src/sql-tools/types';
 
-export const compareEnums: Comparer<DatabaseEnum> = {
+export const compareEnums = (): Comparer<DatabaseEnum> => ({
   onMissing: (source) => [
     {
       type: 'EnumCreate',
@@ -35,4 +35,4 @@ export const compareEnums: Comparer<DatabaseEnum> = {
 
     return [];
   },
-};
+});

server/src/sql-tools/comparers/extension.comparer.spec.ts

@@ -7,7 +7,7 @@ const testExtension = { name: 'test', synchronize: true };
 describe('compareExtensions', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareExtensions.onExtra(testExtension)).toEqual([
+      expect(compareExtensions().onExtra(testExtension)).toEqual([
         {
           extensionName: 'test',
           type: 'ExtensionDrop',
@@ -19,7 +19,7 @@ describe('compareExtensions', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareExtensions.onMissing(testExtension)).toEqual([
+      expect(compareExtensions().onMissing(testExtension)).toEqual([
         {
           type: 'ExtensionCreate',
           extension: testExtension,
@@ -31,7 +31,7 @@ describe('compareExtensions', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareExtensions.onCompare(testExtension, testExtension)).toEqual([]);
+      expect(compareExtensions().onCompare(testExtension, testExtension)).toEqual([]);
     });
   });
 });

server/src/sql-tools/comparers/extension.comparer.ts

@@ -1,6 +1,6 @@
 import { Comparer, DatabaseExtension, Reason } from 'src/sql-tools/types';
 
-export const compareExtensions: Comparer<DatabaseExtension> = {
+export const compareExtensions = (): Comparer<DatabaseExtension> => ({
   onMissing: (source) => [
     {
       type: 'ExtensionCreate',
@@ -19,4 +19,4 @@ export const compareExtensions: Comparer<DatabaseExtension> = {
     // if the name matches they are the same
     return [];
   },
-};
+});

server/src/sql-tools/comparers/function.comparer.spec.ts

@@ -11,7 +11,7 @@ const testFunction: DatabaseFunction = {
 describe('compareFunctions', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareFunctions.onExtra(testFunction)).toEqual([
+      expect(compareFunctions().onExtra(testFunction)).toEqual([
         {
           functionName: 'test',
           type: 'FunctionDrop',
@@ -23,7 +23,7 @@ describe('compareFunctions', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareFunctions.onMissing(testFunction)).toEqual([
+      expect(compareFunctions().onMissing(testFunction)).toEqual([
         {
           type: 'FunctionCreate',
           function: testFunction,
@@ -35,13 +35,13 @@ describe('compareFunctions', () => {
 
   describe('onCompare', () => {
     it('should ignore functions with the same hash', () => {
-      expect(compareFunctions.onCompare(testFunction, testFunction)).toEqual([]);
+      expect(compareFunctions().onCompare(testFunction, testFunction)).toEqual([]);
     });
 
     it('should report differences if functions have different hashes', () => {
       const source: DatabaseFunction = { ...testFunction, expression: 'SELECT 1' };
       const target: DatabaseFunction = { ...testFunction, expression: 'SELECT 2' };
-      expect(compareFunctions.onCompare(source, target)).toEqual([
+      expect(compareFunctions().onCompare(source, target)).toEqual([
         {
           type: 'FunctionCreate',
           reason: 'function expression has changed (SELECT 1 vs SELECT 2)',

server/src/sql-tools/comparers/function.comparer.ts

@@ -1,6 +1,6 @@
 import { Comparer, DatabaseFunction, Reason } from 'src/sql-tools/types';
 
-export const compareFunctions: Comparer<DatabaseFunction> = {
+export const compareFunctions = (): Comparer<DatabaseFunction> => ({
   onMissing: (source) => [
     {
       type: 'FunctionCreate',
@@ -29,4 +29,4 @@ export const compareFunctions: Comparer<DatabaseFunction> = {
 
     return [];
   },
-};
+});

server/src/sql-tools/comparers/index.comparer.spec.ts

@@ -13,7 +13,7 @@ const testIndex: DatabaseIndex = {
 describe('compareIndexes', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareIndexes.onExtra(testIndex)).toEqual([
+      expect(compareIndexes().onExtra(testIndex)).toEqual([
         {
           type: 'IndexDrop',
           indexName: 'test',
@@ -25,7 +25,7 @@ describe('compareIndexes', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareIndexes.onMissing(testIndex)).toEqual([
+      expect(compareIndexes().onMissing(testIndex)).toEqual([
         {
           type: 'IndexCreate',
           index: testIndex,
@@ -37,7 +37,7 @@ describe('compareIndexes', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareIndexes.onCompare(testIndex, testIndex)).toEqual([]);
+      expect(compareIndexes().onCompare(testIndex, testIndex)).toEqual([]);
     });
 
     it('should drop and recreate when column list is different', () => {
@@ -55,7 +55,7 @@ describe('compareIndexes', () => {
         unique: true,
         synchronize: true,
       };
-      expect(compareIndexes.onCompare(source, target)).toEqual([
+      expect(compareIndexes().onCompare(source, target)).toEqual([
         {
           indexName: 'test',
           type: 'IndexDrop',

server/src/sql-tools/comparers/index.comparer.ts

@@ -1,7 +1,7 @@
 import { asRenameKey, haveEqualColumns } from 'src/sql-tools/helpers';
 import { Comparer, DatabaseIndex, Reason } from 'src/sql-tools/types';
 
-export const compareIndexes: Comparer<DatabaseIndex> = {
+export const compareIndexes = (): Comparer<DatabaseIndex> => ({
   getRenameKey: (index) => {
     if (index.override) {
       return index.override.value.sql.replace(index.name, 'INDEX_NAME');
@@ -59,4 +59,4 @@ export const compareIndexes: Comparer<DatabaseIndex> = {
 
     return [];
   },
-};
+});

server/src/sql-tools/comparers/override.comparer.spec.ts

@@ -11,7 +11,7 @@ const testOverride: DatabaseOverride = {
 describe('compareOverrides', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareOverrides.onExtra(testOverride)).toEqual([
+      expect(compareOverrides().onExtra(testOverride)).toEqual([
         {
           type: 'OverrideDrop',
           overrideName: 'test',
@@ -23,7 +23,7 @@ describe('compareOverrides', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareOverrides.onMissing(testOverride)).toEqual([
+      expect(compareOverrides().onMissing(testOverride)).toEqual([
         {
           type: 'OverrideCreate',
           override: testOverride,
@@ -35,7 +35,7 @@ describe('compareOverrides', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareOverrides.onCompare(testOverride, testOverride)).toEqual([]);
+      expect(compareOverrides().onCompare(testOverride, testOverride)).toEqual([]);
     });
 
     it('should drop and recreate when the value changes', () => {
@@ -57,7 +57,7 @@ describe('compareOverrides', () => {
         },
         synchronize: true,
       };
-      expect(compareOverrides.onCompare(source, target)).toEqual([
+      expect(compareOverrides().onCompare(source, target)).toEqual([
         {
           override: source,
           type: 'OverrideUpdate',

server/src/sql-tools/comparers/override.comparer.ts

@@ -1,6 +1,6 @@
 import { Comparer, DatabaseOverride, Reason } from 'src/sql-tools/types';
 
-export const compareOverrides: Comparer<DatabaseOverride> = {
+export const compareOverrides = (): Comparer<DatabaseOverride> => ({
   onMissing: (source) => [
     {
       type: 'OverrideCreate',
@@ -26,4 +26,4 @@ export const compareOverrides: Comparer<DatabaseOverride> = {
 
     return [];
   },
-};
+});

server/src/sql-tools/comparers/parameter.comparer.spec.ts

@@ -13,7 +13,7 @@ const testParameter: DatabaseParameter = {
 describe('compareParameters', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareParameters.onExtra(testParameter)).toEqual([
+      expect(compareParameters().onExtra(testParameter)).toEqual([
         {
           type: 'ParameterReset',
           databaseName: 'immich',
@@ -26,7 +26,7 @@ describe('compareParameters', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareParameters.onMissing(testParameter)).toEqual([
+      expect(compareParameters().onMissing(testParameter)).toEqual([
         {
           type: 'ParameterSet',
           parameter: testParameter,
@@ -38,7 +38,7 @@ describe('compareParameters', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareParameters.onCompare(testParameter, testParameter)).toEqual([]);
+      expect(compareParameters().onCompare(testParameter, testParameter)).toEqual([]);
     });
   });
 });

server/src/sql-tools/comparers/parameter.comparer.ts

@@ -1,6 +1,6 @@
 import { Comparer, DatabaseParameter, Reason } from 'src/sql-tools/types';
 
-export const compareParameters: Comparer<DatabaseParameter> = {
+export const compareParameters = (): Comparer<DatabaseParameter> => ({
   onMissing: (source) => [
     {
       type: 'ParameterSet',
@@ -20,4 +20,4 @@ export const compareParameters: Comparer<DatabaseParameter> = {
     // TODO
     return [];
   },
-};
+});

server/src/sql-tools/comparers/table.comparer.spec.ts

@@ -14,7 +14,7 @@ const testTable: DatabaseTable = {
 describe('compareParameters', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareTables.onExtra(testTable)).toEqual([
+      expect(compareTables({}).onExtra(testTable)).toEqual([
         {
           type: 'TableDrop',
           tableName: 'test',
@@ -26,7 +26,7 @@ describe('compareParameters', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareTables.onMissing(testTable)).toEqual([
+      expect(compareTables({}).onMissing(testTable)).toEqual([
         {
           type: 'TableCreate',
           table: testTable,
@@ -38,7 +38,7 @@ describe('compareParameters', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareTables.onCompare(testTable, testTable)).toEqual([]);
+      expect(compareTables({}).onCompare(testTable, testTable)).toEqual([]);
     });
   });
 });

server/src/sql-tools/comparers/table.comparer.ts

@@ -3,9 +3,9 @@ import { compareConstraints } from 'src/sql-tools/comparers/constraint.comparer'
 import { compareIndexes } from 'src/sql-tools/comparers/index.comparer';
 import { compareTriggers } from 'src/sql-tools/comparers/trigger.comparer';
 import { compare } from 'src/sql-tools/helpers';
-import { Comparer, DatabaseTable, Reason, SchemaDiff } from 'src/sql-tools/types';
+import { Comparer, DatabaseTable, Reason, SchemaDiffOptions } from 'src/sql-tools/types';
 
-export const compareTables: Comparer<DatabaseTable> = {
+export const compareTables = (options: SchemaDiffOptions): Comparer<DatabaseTable> => ({
   onMissing: (source) => [
     {
       type: 'TableCreate',
@@ -20,14 +20,12 @@ export const compareTables: Comparer<DatabaseTable> = {
       reason: Reason.MissingInSource,
     },
   ],
-  onCompare: (source, target) => compareTable(source, target),
-};
-
-const compareTable = (source: DatabaseTable, target: DatabaseTable): SchemaDiff[] => {
-  return [
-    ...compare(source.columns, target.columns, {}, compareColumns),
-    ...compare(source.indexes, target.indexes, {}, compareIndexes),
-    ...compare(source.constraints, target.constraints, {}, compareConstraints),
-    ...compare(source.triggers, target.triggers, {}, compareTriggers),
-  ];
-};
+  onCompare: (source, target) => {
+    return [
+      ...compare(source.columns, target.columns, options.columns, compareColumns()),
+      ...compare(source.indexes, target.indexes, options.indexes, compareIndexes()),
+      ...compare(source.constraints, target.constraints, options.constraints, compareConstraints()),
+      ...compare(source.triggers, target.triggers, options.triggers, compareTriggers()),
+    ];
+  },
+});

server/src/sql-tools/comparers/trigger.comparer.spec.ts

@@ -15,7 +15,7 @@ const testTrigger: DatabaseTrigger = {
 describe('compareTriggers', () => {
   describe('onExtra', () => {
     it('should work', () => {
-      expect(compareTriggers.onExtra(testTrigger)).toEqual([
+      expect(compareTriggers().onExtra(testTrigger)).toEqual([
         {
           type: 'TriggerDrop',
           tableName: 'table1',
@@ -28,7 +28,7 @@ describe('compareTriggers', () => {
 
   describe('onMissing', () => {
     it('should work', () => {
-      expect(compareTriggers.onMissing(testTrigger)).toEqual([
+      expect(compareTriggers().onMissing(testTrigger)).toEqual([
         {
           type: 'TriggerCreate',
           trigger: testTrigger,
@@ -40,49 +40,49 @@ describe('compareTriggers', () => {
 
   describe('onCompare', () => {
     it('should work', () => {
-      expect(compareTriggers.onCompare(testTrigger, testTrigger)).toEqual([]);
+      expect(compareTriggers().onCompare(testTrigger, testTrigger)).toEqual([]);
     });
 
     it('should detect a change in function name', () => {
       const source: DatabaseTrigger = { ...testTrigger, functionName: 'my_new_name' };
       const target: DatabaseTrigger = { ...testTrigger, functionName: 'my_old_name' };
       const reason = `function is different (my_new_name vs my_old_name)`;
-      expect(compareTriggers.onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
+      expect(compareTriggers().onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
     });
 
     it('should detect a change in actions', () => {
       const source: DatabaseTrigger = { ...testTrigger, actions: ['delete'] };
       const target: DatabaseTrigger = { ...testTrigger, actions: ['delete', 'insert'] };
       const reason = `action is different (delete vs delete,insert)`;
-      expect(compareTriggers.onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
+      expect(compareTriggers().onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
     });
 
     it('should detect a change in timing', () => {
       const source: DatabaseTrigger = { ...testTrigger, timing: 'before' };
       const target: DatabaseTrigger = { ...testTrigger, timing: 'after' };
       const reason = `timing method is different (before vs after)`;
-      expect(compareTriggers.onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
+      expect(compareTriggers().onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
     });
 
     it('should detect a change in scope', () => {
       const source: DatabaseTrigger = { ...testTrigger, scope: 'row' };
       const target: DatabaseTrigger = { ...testTrigger, scope: 'statement' };
       const reason = `scope is different (row vs statement)`;
-      expect(compareTriggers.onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
+      expect(compareTriggers().onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
     });
 
     it('should detect a change in new table reference', () => {
       const source: DatabaseTrigger = { ...testTrigger, referencingNewTableAs: 'new_table' };
       const target: DatabaseTrigger = { ...testTrigger, referencingNewTableAs: undefined };
       const reason = `new table reference is different (new_table vs undefined)`;
-      expect(compareTriggers.onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
+      expect(compareTriggers().onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
     });
 
     it('should detect a change in old table reference', () => {
       const source: DatabaseTrigger = { ...testTrigger, referencingOldTableAs: 'old_table' };
       const target: DatabaseTrigger = { ...testTrigger, referencingOldTableAs: undefined };
       const reason = `old table reference is different (old_table vs undefined)`;
-      expect(compareTriggers.onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
+      expect(compareTriggers().onCompare(source, target)).toEqual([{ type: 'TriggerCreate', trigger: source, reason }]);
     });
   });
 });

server/src/sql-tools/comparers/trigger.comparer.ts

@@ -1,6 +1,6 @@
 import { Comparer, DatabaseTrigger, Reason } from 'src/sql-tools/types';
 
-export const compareTriggers: Comparer<DatabaseTrigger> = {
+export const compareTriggers = (): Comparer<DatabaseTrigger> => ({
   onMissing: (source) => [
     {
       type: 'TriggerCreate',
@@ -38,4 +38,4 @@ export const compareTriggers: Comparer<DatabaseTrigger> = {
 
     return [];
   },
-};
+});