@dbml/connector 5.0.0 → 5.2.0

package/src/connectors/postgresConnector.ts

@@ -1,7 +1,7 @@
-/* eslint-disable camelcase */
 import { Client } from 'pg';
 import { buildSchemaQuery, parseConnectionString } from '../utils/parseSchema';
 import {
+  CheckConstraintDictionary,
   DatabaseSchema,
   DefaultInfo,
   DefaultType,
@@ -96,13 +96,15 @@ const generateField = (row: Record<string, any>): Field => {
 
   const dbdefault = column_default && default_type !== 'increment' ? getDbdefault(data_type, column_default, default_type) : null;
 
-  const fieldType = data_type === 'USER-DEFINED' ? {
-    type_name: udt_name,
-    schemaName: udt_schema,
-  } : {
-    type_name: getFieldType(data_type, udt_name, character_maximum_length, numeric_precision, numeric_scale),
-    schemaName: null,
-  };
+  const fieldType = data_type === 'USER-DEFINED'
+    ? {
+        type_name: udt_name,
+        schemaName: udt_schema,
+      }
+    : {
+        type_name: getFieldType(data_type, udt_name, character_maximum_length, numeric_precision, numeric_scale),
+        schemaName: null,
+      };
 
   return {
     name: column_name,
@@ -115,8 +117,8 @@ const generateField = (row: Record<string, any>): Field => {
 };
 
 const generateTablesAndFields = async (client: Client, schemas: string[]): Promise<{
-  tables: Table[],
-  fields: FieldsDictionary,
+  tables: Table[];
+  fields: FieldsDictionary;
 }> => {
   const fields: FieldsDictionary = {};
   const tablesAndFieldsSql = `
@@ -301,7 +303,7 @@ const generateRawRefs = async (client: Client, schemas: string[]): Promise<Ref[]
   return refs;
 };
 
-const generateIndexes = async (client: Client, schemas: string[]) => {
+const generateIndexesAndConstraints = async (client: Client, schemas: string[]) => {
   const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -348,8 +350,8 @@ const generateIndexes = async (client: Client, schemas: string[]) => {
       ii.is_unique,
       ii.is_primary,
       ii.index_type,
-      ii.columns,
-      ii.expressions,
+      ii.columns AS index_columns,
+      ii.expressions AS index_expressions,
       ii.constraint_type  -- Retained constraint type here
     FROM
       user_tables ut
@@ -364,43 +366,47 @@ const generateIndexes = async (client: Client, schemas: string[]) => {
     ;
   `;
   const indexListResult = await client.query(indexListSql);
-  const { outOfLineConstraints, inlineConstraints } = indexListResult.rows.reduce((acc, row) => {
-    const { constraint_type, columns } = row;
+  const { outOfLineIndexes, inlineIndexes } = indexListResult.rows.reduce((acc, row) => {
+    const { constraint_type, index_columns } = row;
 
-    if (columns === 'null' || columns.trim() === '') return acc;
+    if (index_columns === 'null' || index_columns.trim() === '') return acc;
 
-    const isSingleColumn = columns.split(',').length === 1;
-    const isInlineConstraint = isSingleColumn && (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE');
-    if (isInlineConstraint) {
-      acc.inlineConstraints.push(row);
+    const isSingleColumn = index_columns.split(',').length === 1;
+    const isInlineIndex = isSingleColumn && (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE');
+    if (isInlineIndex) {
+      acc.inlineIndexes.push(row);
     } else {
-      acc.outOfLineConstraints.push(row);
+      acc.outOfLineIndexes.push(row);
     }
     return acc;
-  }, { outOfLineConstraints: [], inlineConstraints: [] });
+  }, { outOfLineIndexes: [], inlineIndexes: [] });
 
-  const indexes = outOfLineConstraints.reduce((acc: IndexesDictionary, indexRow: Record<string, any>) => {
+  const indexes = outOfLineIndexes.reduce((acc: IndexesDictionary, indexRow: Record<string, any>) => {
     const {
       table_schema,
       table_name,
       index_name,
       index_type,
-      columns,
-      expressions,
+      index_columns,
+      index_expressions,
+      is_primary,
+      is_unique,
     } = indexRow;
-    const indexColumns = columns.split(',').map((column: string) => {
+    const indexColumns = index_columns.split(',').map((column: string) => {
       return {
         type: 'column',
         value: column.trim(),
       };
     });
 
-    const indexExpressions = expressions ? expressions.split(',').map((expression: string) => {
-      return {
-        type: 'expression',
-        value: expression,
-      };
-    }) : [];
+    const indexExpressions = index_expressions
+      ? index_expressions.split(',').map((expression: string) => {
+          return {
+            type: 'expression',
+            value: expression,
+          };
+        })
+      : [];
 
     const index = {
       name: index_name,
@@ -409,6 +415,8 @@ const generateIndexes = async (client: Client, schemas: string[]) => {
         ...indexColumns,
         ...indexExpressions,
       ],
+      pk: !!is_primary,
+      unique: !is_primary && !!is_unique,
     };
 
     const key = `${table_schema}.${table_name}`;
@@ -421,32 +429,105 @@ const generateIndexes = async (client: Client, schemas: string[]) => {
     return acc;
   }, {});
 
-  const tableConstraints = inlineConstraints.reduce((acc: TableConstraintsDictionary, row: Record<string, any>) => {
+  const tableConstraints: TableConstraintsDictionary = {};
+
+  inlineIndexes.forEach((row: Record<string, any>) => {
     const {
       table_schema,
       table_name,
-      columns,
+      index_columns,
       constraint_type,
     } = row;
     const key = `${table_schema}.${table_name}`;
-    if (!acc[key]) acc[key] = {};
+    if (!tableConstraints[key]) tableConstraints[key] = {};
 
-    const columnNames = columns.split(',').map((column: string) => column.trim());
+    const columnNames = index_columns.split(',').map((column: string) => column.trim());
     columnNames.forEach((columnName: string) => {
-      if (!acc[key][columnName]) acc[key][columnName] = {};
+      if (!tableConstraints[key][columnName]) tableConstraints[key][columnName] = { checks: [] };
       if (constraint_type === 'PRIMARY KEY') {
-        acc[key][columnName].pk = true;
+        tableConstraints[key][columnName].pk = true;
       }
-      if (constraint_type === 'UNIQUE' && !acc[key][columnName].pk) {
-        acc[key][columnName].unique = true;
+      if (constraint_type === 'UNIQUE' && !tableConstraints[key][columnName].pk) {
+        tableConstraints[key][columnName].unique = true;
       }
     });
-    return acc;
   }, {});
 
+  const checkListSql = `
+    SELECT
+      n.nspname AS table_schema,
+      c.relname AS table_name,
+      MAX(a.attname) AS column_name,
+      con.conname AS check_name,
+      pg_get_constraintdef(con.oid) AS check_definition,
+      CASE
+        WHEN COUNT(*) = 1 THEN TRUE
+        ELSE FALSE
+      END AS is_column_constraint 
+    FROM
+      pg_catalog.pg_constraint AS con
+    JOIN
+      pg_catalog.pg_class AS c
+      ON con.conrelid = c.oid
+    LEFT JOIN
+      pg_catalog.pg_namespace AS n
+      ON c.relnamespace = n.oid
+    LEFT JOIN
+      pg_catalog.pg_attribute AS a
+      ON a.attrelid = c.oid AND a.attnum = ANY(con.conkey)
+    WHERE con.contype = 'c' -- 'c' for CHECK constraints
+    ${buildSchemaQuery('n.nspname', schemas)}
+    GROUP BY
+      con.conname,
+      n.nspname,
+      c.relname,
+      con.oid
+  `;
+  const checkListResult = await client.query(checkListSql);
+  const checks: CheckConstraintDictionary = {};
+  checkListResult.rows.forEach((row) => {
+    const {
+      table_schema,
+      table_name,
+      check_name,
+      check_definition,
+      column_name,
+      is_column_constraint,
+    } = row;
+    if (typeof table_schema !== 'string' || typeof table_name !== 'string' || typeof check_definition !== 'string') {
+      return;
+    }
+    if (!check_definition.match(/CHECK \(\(.*\)\)/)) {
+      return;
+    }
+    if (is_column_constraint && typeof column_name !== 'string') {
+      return;
+    }
+    const key = `${table_schema}.${table_name}`;
+    if (is_column_constraint) {
+      if (!tableConstraints[key]) tableConstraints[key] = {};
+      if (!tableConstraints[key][column_name]) tableConstraints[key][column_name] = { checks: [] };
+      tableConstraints[key][column_name].checks.push({
+        name: check_name || undefined,
+        // The check definition has the form: `CHECK ((expr))`
+        // The expression starts at 8 and ends at -2
+        expression: check_definition.slice(8, -2),
+      });
+      return;
+    }
+    if (!checks[key]) checks[key] = [];
+    checks[key].push({
+      name: check_name || undefined,
+      // The check definition has the form: `CHECK ((expr))`
+      // The expression starts at 8 and ends at -2
+      expression: check_definition.slice(8, -2),
+    });
+  });
+
   return {
     indexes,
     tableConstraints,
+    checks,
   };
 };
 
@@ -496,7 +577,7 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
   const client = await getValidatedClient(connectionString);
 
   const tablesAndFieldsRes = generateTablesAndFields(client, schemas);
-  const indexesRes = generateIndexes(client, schemas);
+  const indexesRes = generateIndexesAndConstraints(client, schemas);
   const refsRes = generateRawRefs(client, schemas);
   const enumsRes = generateRawEnums(client, schemas);
 
@@ -509,7 +590,7 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
   client.end();
 
   const { tables, fields } = res[0];
-  const { indexes, tableConstraints } = res[1];
+  const { indexes, tableConstraints, checks } = res[1];
   const refs = res[2];
   const enums = res[3];
 
@@ -520,9 +601,10 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
     enums,
     indexes,
     tableConstraints,
+    checks,
   };
 };
 
 export {
-  fetchSchemaJson
+  fetchSchemaJson,
 };

package/src/connectors/snowflakeConnector.ts

@@ -1,4 +1,3 @@
-/* eslint-disable camelcase */
 //
 // Description:
 // Snowflake info schema lacks reference direction for relationships.
@@ -43,12 +42,11 @@ const parseConnectionString = (connectionString: string): Record<string, string>
   let match;
 
   while ((match = regex.exec(connectionString)) !== null) {
-      params[match[1].trim()] = match[2].trim();
+    params[match[1].trim()] = match[2].trim();
   }
 
   return params;
-}
-
+};
 
 const connect = async (connection: Connection): Promise<void> => {
   return new Promise((resolve, reject) => {
@@ -61,13 +59,13 @@ const connect = async (connection: Connection): Promise<void> => {
       }
     });
   });
-}
+};
 
 const executeQuery = (connection: Connection, sqlText: string): Promise<any[]> => {
   return new Promise((resolve, reject) => {
     console.log('Executing query...');
     connection.execute({
-      sqlText: sqlText,
+      sqlText,
       complete: (err, stmt, rows) => {
         if (err) {
           reject(err);
@@ -77,14 +75,14 @@ const executeQuery = (connection: Connection, sqlText: string): Promise<any[]> =
             resolve(rows);
           }
         }
-      }
+      },
     });
   });
-}
+};
 
 const isLogLevel = (value: string): value is LogLevel => {
-  return ['ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'].includes(value as LogLevel)
-}
+  return ['ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'].includes(value as LogLevel);
+};
 
 const connectToSnowflake = async (config: Record<string, string>): Promise<Connection> => {
   const logLevel = isLogLevel(config.LOG_LEVEL) ? config.LOG_LEVEL : 'INFO';
@@ -197,8 +195,8 @@ const generateField = (row: Record<string, any>): Field => {
 };
 
 const generateTablesAndFields = async (conn: Connection, schemas: string[]): Promise<{
-  tables: Table[],
-  fields: FieldsDictionary,
+  tables: Table[];
+  fields: FieldsDictionary;
 }> => {
   const fields: FieldsDictionary = {};
   const schemaSql = schemas.length > 0 ? `AND c.table_schema IN (${schemas.map((schema) => `'${schema}'`).join(',')})` : '';
@@ -266,14 +264,18 @@ const generateTablesAndFields = async (conn: Connection, schemas: string[]): Pro
 
 const createConstraintKeysMap = (keys: Record<string, string>[], schemas: string[], constraintType: 'primary' | 'unique'): Record<string, ConstraintRow> => {
   return keys.reduce((acc: Record<string, ConstraintRow>, row: Record<string, string>) => {
-    const { schema_name, table_name, column_name, constraint_name } = row;
+    const {
+      schema_name, table_name, column_name, constraint_name,
+    } = row;
     const selectedSchema = schemas.length > 0 ? schemas.includes(schema_name) : true;
-    if (!selectedSchema) { return acc; }
+    if (!selectedSchema) {
+      return acc;
+    }
 
     const key = `${schema_name}.${table_name}.${constraint_name}`;
 
     if (acc[key]) {
-      const columnNames = acc[key].columnNames;
+      const { columnNames } = acc[key];
       columnNames.push(column_name);
       return acc;
     }
@@ -291,8 +293,6 @@ const createConstraintKeysMap = (keys: Record<string, string>[], schemas: string
   }, {});
 };
 const generateIndexes = async (conn: Connection, databaseName: string, schemas: string[]) => {
-
-
   const getPrimaryKeysSql = `
     SHOW PRIMARY KEYS IN DATABASE ${databaseName};
   `;
@@ -309,7 +309,9 @@ const generateIndexes = async (conn: Connection, databaseName: string, schemas:
 
   const allConstraints: ConstraintRow[] = [Object.values(primaryKeysByConstraint), Object.values(uniqueKeysByConstraint)].flat();
   const { indexes, tableConstraints } = allConstraints.reduce((acc: GeneratedIndexes, row: ConstraintRow): GeneratedIndexes => {
-    const { schemaName, tableName, constraintName, columnNames, type, primary, unique } = row;
+    const {
+      schemaName, tableName, constraintName, columnNames, type, primary, unique,
+    } = row;
     const key = `${schemaName}.${tableName}`;
 
     if (columnNames.length < 2) {
@@ -317,6 +319,7 @@ const generateIndexes = async (conn: Connection, databaseName: string, schemas:
         [columnNames[0]]: {
           pk: primary,
           unique,
+          checks: [],
         },
       };
       return acc;
@@ -340,7 +343,7 @@ const generateIndexes = async (conn: Connection, databaseName: string, schemas:
     }
 
     return acc;
-  }, { indexes: {}, tableConstraints: {}});
+  }, { indexes: {}, tableConstraints: {} });
 
   return {
     indexes,
@@ -384,6 +387,8 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
     enums: [],
     indexes,
     tableConstraints,
+    // Checks are not supported in snowflake
+    checks: {},
   };
 };
 

package/src/connectors/types.ts

@@ -1,5 +1,3 @@
-import { columns } from "mssql";
-
 interface NoteInfo {
   value: string;
 }
@@ -9,11 +7,10 @@ interface TypeInfo {
   schemaName: string | null;
 }
 
-
 type DefaultType = 'string' | 'number' | 'boolean' | 'expression';
 
 interface DefaultInfo {
-  type: DefaultType,
+  type: DefaultType;
   value: string;
 }
 
@@ -38,10 +35,20 @@ interface FieldsDictionary {
   [key: string]: Field[]; // Represents fields within tables, indexed by schemaName.tableName
 }
 
+interface CheckConstraint {
+  name?: string;
+  expression: string;
+}
+
+interface CheckConstraintDictionary {
+  [tableName: string]: CheckConstraint[];
+}
+
 interface TableConstraint {
   [fieldName: string]: {
     pk?: boolean;
     unique?: boolean;
+    checks: CheckConstraint[];
   };
 }
 
@@ -81,8 +88,8 @@ interface IndexColumn {
 interface Index {
   name: string;
   type: string;
-  unique?: boolean,
-  pk?: boolean,
+  unique?: boolean;
+  pk?: boolean;
   columns: IndexColumn[];
 }
 
@@ -97,68 +104,16 @@ interface DatabaseSchema {
   tableConstraints: TableConstraintsDictionary;
   refs: Ref[];
   indexes: IndexesDictionary; // Represents the indexes property
+  checks: CheckConstraintDictionary;
 }
 
 interface BigQueryCredentials {
-  projectId?: string,
+  projectId?: string;
   credentials?: {
-    clientEmail: string,
-    privateKey: string,
-  },
-  datasets: string[],
-}
-
-// Currently, we parse the check constraints as enum values in mssql.
-// However, one check constraint can have multiple set of enum values.
-// So, we need to store the enum values in a dictionary.
-// Examples:
-// CREATE TABLE AddressInfo (
-//   A1 UNIQUEIDENTIFIER NOT NULL,
-//   A2 UNIQUEIDENTIFIER NOT NULL,
-//   A3 UNIQUEIDENTIFIER NOT NULL,
-//   A4 UNIQUEIDENTIFIER NOT NULL,
-//   CONSTRAINT CK_Address_Valid CHECK (
-//       A1 IN ('1111', '2222', '333') AND
-//       A2 IN ('1111', '2222') AND
-//       A3 IN ('2222', '1111') AND
-//       A4 IN ('2222', '3333')
-//   )
-// );
-// GO
-// In the above example, we have a check constraint CK_Address_Valid2 with 4 columns: A1, A2, A3, A4.
-// Each column has a different set of enum values. So, we need to store the enum values in a dictionary.
-// In the above example, the enum values dictionary will look like this:
-// [
-//   {
-//     columns : ['A1'],
-//     enumValues: [
-//       { name: '1111' },
-//       { name: '2222' },
-//       { name: '333' }
-//     ],
-//     constraint_name: 'CK_Address_Valid_A1'
-//   },
-//   {
-//     columns : ['A2, A3'], => In this case, these two columns have the same set of enum values.
-//     enumValues: [
-//       { name: '1111' },
-//       { name: '2222' }
-//     ],
-//     constraint_name: 'CK_Address_Valid_A2_A3'
-//   },
-//   {
-//     columns : ['A4'],
-//     enumValues: [
-//       { name: '2222' },
-//       { name: '3333' }
-//     ],
-//     constraint_name: 'CK_Address_Valid_A4'
-//   }
-// ]
-interface EnumValuesDict {
-  columns: string[],
-  enumValues: EnumValue[],
-  constraint_name: string,
+    clientEmail: string;
+    privateKey: string;
+  };
+  datasets: string[];
 }
 
 export {
@@ -180,5 +135,5 @@ export {
   IndexesDictionary,
   DatabaseSchema,
   BigQueryCredentials,
-  EnumValuesDict,
+  CheckConstraintDictionary,
 };

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as connector from "./connectors/connector";
+import * as connector from './connectors/connector';
 
 export {
   connector,

package/src/utils/helpers.ts

@@ -1,15 +1,16 @@
 import {
+  CheckConstraintDictionary,
   FieldsDictionary,
   IndexesDictionary,
   Table,
   TableConstraintsDictionary,
 } from '../connectors/types';
 
-export function getIntersection<T>(firstList: T[], secondList: T[]): T[] {
+export function getIntersection<T> (firstList: T[], secondList: T[]): T[] {
   return firstList.filter((item) => secondList.includes(item));
 }
 
-export function getTableSchemaKey(schemaName: string, tableName: string) {
+export function getTableSchemaKey (schemaName: string, tableName: string) {
   if (!tableName || !tableName.trim()) {
     throw new Error('Table name must be a non-empty string');
   }
@@ -17,15 +18,15 @@ export function getTableSchemaKey(schemaName: string, tableName: string) {
   return schemaName ? `${schemaName}.${tableName}` : `${tableName}`;
 }
 
-export function mergeTables(firstTableList: Table[], secondTable: Table[]): Table[] {
+export function mergeTables (firstTableList: Table[], secondTable: Table[]): Table[] {
   return firstTableList.concat(secondTable);
 }
 
-export function mergeFieldDictionary(
+export function mergeFieldDictionary (
   firstDict: FieldsDictionary,
-  secondDict: FieldsDictionary
+  secondDict: FieldsDictionary,
 ): FieldsDictionary {
-  const result: FieldsDictionary = Object.assign({}, firstDict);
+  const result: FieldsDictionary = { ...firstDict };
 
   Object.keys(secondDict).forEach((key) => {
     if (!result[key]) {
@@ -38,11 +39,11 @@ export function mergeFieldDictionary(
   return result;
 }
 
-export function mergeIndexDictionary(
+export function mergeIndexDictionary (
   firstDict: IndexesDictionary,
-  secondDict: IndexesDictionary
+  secondDict: IndexesDictionary,
 ): IndexesDictionary {
-  const result: IndexesDictionary = Object.assign({}, firstDict);
+  const result: IndexesDictionary = { ...firstDict };
 
   Object.keys(secondDict).forEach((key) => {
     if (!result[key]) {
@@ -55,11 +56,11 @@ export function mergeIndexDictionary(
   return result;
 }
 
-export function mergeTableConstraintDictionary(
+export function mergeTableConstraintDictionary (
   firstDict: TableConstraintsDictionary,
-  secondDict: TableConstraintsDictionary
+  secondDict: TableConstraintsDictionary,
 ): TableConstraintsDictionary {
-  const result: TableConstraintsDictionary = Object.assign({}, firstDict);
+  const result: TableConstraintsDictionary = { ...firstDict };
 
   Object.keys(secondDict).forEach((key) => {
     if (!result[key]) {
@@ -71,3 +72,20 @@ export function mergeTableConstraintDictionary(
 
   return result;
 }
+
+export function mergeCheckConstraintDictionary (
+  firstDict: CheckConstraintDictionary,
+  secondDict: CheckConstraintDictionary,
+): CheckConstraintDictionary {
+  const result: CheckConstraintDictionary = { ...firstDict };
+
+  Object.keys(secondDict).forEach((key) => {
+    if (!result[key]) {
+      result[key] = [];
+    }
+
+    result[key] = result[key].concat(secondDict[key]);
+  });
+
+  return result;
+}

package/src/utils/parseSchema.ts

@@ -14,6 +14,17 @@ const noSchemaResult = (connectionString: string) => ({
   schemas: [],
 });
 
+// Inputs: schemas string -> Output: schema array string[]
+// schema1, schema2 -> ['schema1', 'schema2']
+// schema3,schema4 -> ['schema3", 'schema4']
+// "schema5,gg", "schema6", schema7 -> ['schema5,gg', 'schema6', 'schema7']
+// schema8 -> ['schema8']
+export const parseSchema = (schemas: string | undefined): string[] => {
+  if (!schemas) return [];
+  const schemasWithDoubleQuotes = schemas.split(/,(?=(?:[^"]*(?:"[^"]*")*)*$)/).map((s) => s.trim());
+  return schemasWithDoubleQuotes.map((s) => s.replace(/"/g, ''));
+};
+
 const parseOdbcSchema = (connectionString: string) => {
   const connectionParts = connectionString.split(';');
   const schemasPart = connectionParts.find((part) => haveSchemas(part));
@@ -47,14 +58,3 @@ export const buildSchemaQuery = (columnName: string, schemas: string[], prefix =
   if (schemas.length === 0) return '';
   return `${prefix} ${columnName} IN (${schemas.map((schema) => `'${schema}'`).join(', ')})`;
 };
-
-// Inputs: schemas string -> Output: schema array string[]
-// schema1, schema2 -> ['schema1', 'schema2']
-// schema3,schema4 -> ['schema3", 'schema4']
-// "schema5,gg", "schema6", schema7 -> ['schema5,gg', 'schema6', 'schema7']
-// schema8 -> ['schema8']
-export const parseSchema = (schemas: string | undefined): string[] => {
-  if (!schemas) return [];
-  const schemasWithDoubleQuotes = schemas.split(/,(?=(?:[^"]*(?:"[^"]*")*)*$)/).map((s) => s.trim());
-  return schemasWithDoubleQuotes.map((s) => s.replace(/"/g, ''));
-};

package/test-output.log

@@ -0,0 +1,18 @@
+
+> @dbml/connector@5.1.0 test
+> jest
+
+PASS __tests__/connector.test.ts
+  @dbml/connector
+    ✓ connectors/mssql (264 ms)
+    ✓ connectors/mysql (31 ms)
+    ✓ connectors/postgres (55 ms)
+
+Test Suites: 1 passed, 1 total
+Tests:       3 passed, 3 total
+Snapshots:   0 total
+Time:        1.208 s, estimated 2 s
+Ran all test suites.
+Jest did not exit one second after the test run has completed.
+
+'This usually means that there are asynchronous operations that weren't stopped in your tests. Consider running Jest with `--detectOpenHandles` to troubleshoot this issue.