af-db-ts 2.0.19 → 2.0.73

package/src/@types/i-pg.ts

@@ -1,39 +1,13 @@
 import { Pool, PoolClient } from 'pg';
+import { IFieldDef, TFieldName } from './i-common';
+import { TDataTypePg } from './i-data-types-pg';
 
-export enum EDataTypePg {
-  'USER_DEFINED' = 'USER-DEFINED',
-  'bigint' = 'bigint',
-  'boolean' = 'boolean',
-  'character' = 'character',
-  'varchar' = 'character varying',
-  'date' = 'date',
-  'integer' = 'integer',
-  'json' = 'json',
-  'jsonb' = 'jsonb',
-  'numeric' = 'numeric',
-  'real' = 'real',
-  'smallint' = 'smallint',
-  'text' = 'text',
-  'timestamptz' = 'timestamp with time zone',
-  'timestamp' = 'timestamp without time zone',
-  'uuid' = 'uuid',
-  'ARRAY' = 'ARRAY',
+export interface IFieldDefPg extends IFieldDef {
+  dataType?: TDataTypePg,
+  arrayType?: TDataTypePg,
 }
 
-export interface IFieldDefPg {
-  name: string,
-  isNullable: boolean,
-  columnDefault: string | number | boolean,
-  hasDefault: boolean,
-  dataType: EDataTypePg,
-  maxLen?: number,
-  precision?: number,
-  radix?: number,
-  dtPrecision?: number,
-  udtName?: string,
-}
-
-export interface TRecordSchemaPg {
+export interface TColumnsSchemaPg {
   [fieldName: string]: IFieldDefPg,
 }
 
@@ -42,13 +16,14 @@ export interface TUniqueConstraintsPg {
 }
 
 export interface ITableSchemaPg {
-  recordSchema: TRecordSchemaPg,
+  columnsSchema: TColumnsSchemaPg,
   pk: string[],
   uc: TUniqueConstraintsPg,
-  serials: string[],
   defaults: { [fieldName: string]: string },
-  fieldsList: string[],
-  fieldsWoSerials: string[],
+  fieldsArray: TFieldName[], // массив имен всех полей
+  serialsFields: TFieldName[], // массив имен полей типа identity
+  readOnlyFields: TFieldName[], // массив имен полей ReadOnly
+  fieldsWoSerialsAndRO: TFieldName[], // массив имен полей без полей identity и ReadOnly
 }
 
 export interface IPoolClientPg extends PoolClient {

package/src/common.ts

@@ -1,8 +1,10 @@
 import { magenta } from 'af-color';
-import { closeAllPgConnectionsPg } from './pg/pg-pool';
-import { closeAllDbConnectionsMs } from './mssql/pool-ms';
+import { closeAllPgConnectionsPg } from './pg/pool-pg';
+import { closeAllDbConnectionsMs } from './ms/pool-ms';
 import { logger } from './logger-error';
 
+export const NULL = 'null';
+
 export const logSqlError = (err: Error | any, throwError?: boolean, textSQL?: string, prefix?: string) => {
   if (prefix) {
     logger.error(prefix);

package/src/index.ts

@@ -20,79 +20,120 @@ export {
 } from './@types/i-config';
 
 export {
-  IFieldSchemaMs,
-  IGetValueForSqlArgsMs,
+  closeAllDb,
+  graceExit,
+  logSqlError,
+} from './common';
+
+export { setLogger } from './logger-error';
+
+export {
+  schemaTable,
+  prepareJSON,
+  binToHexString,
+  removePairBrackets,
+  q,
+} from './utils/utils';
+
+export {
+  getLuxonDT,
+  getTypeOfDateInput,
+  dateTimeValue,
+  getDatetimeWithPrecisionAndOffset,
+} from './utils/utils-dt';
+
+export {
+  parseIntNumber,
+  prepareIntNumber,
+
+  parseFloatNumber,
+  prepareFloatNumber,
+
+  prepareBigIntNumber,
+} from './utils/utils-num';
+
+// ######################### MS #####################################
+
+export { TDataTypeMs } from './@types/i-data-types-ms';
+
+export {
+  IFieldDefMs,
+  TColumnsSchemaMs,
+  ITableSchemaMs,
+  TUniqueConstraintsMs,
   IConnectionPoolsMs,
-  IPrepareSqlStringArgsMs,
-  TRecordSchemaAssocMs,
-  IGetMergeSQLOptionsMs,
-  IPrepareRecordForSqlArgsMs,
-  IPrepareRecordParamsMs,
-  ISchemaArrayMs,
-  IValueForSQLPartialArgsMs,
-  TFieldTypeCorrectionMs,
-  ISchemaItemMs,
-  TGetRecordSchemaOptionsMs,
-  TGetRecordSchemaResultMs,
-  TMergeResultMs,
-  TMergeRulesMs,
-  TRecordSchemaMs,
   TGetPoolConnectionOptionsMs,
 } from './@types/i-ms';
 
 export {
-  IFieldDefPg,
-  TRecordSchemaPg,
-  ITableSchemaPg,
-  EDataTypePg,
-  TUniqueConstraintsPg,
-  IPoolPg,
-  IConnectionPoolsPg,
-  IPoolClientPg,
-} from './@types/i-pg';
+  genTableInterfaceMs,
+  genTableInterfacesMs,
+} from './ms/gen-table-interfaces-ms';
 
-export {
-  getValueForSqlMs,
-  binToHexString,
-  getValueForSQL,
-} from './mssql/get-value-for-sql';
+export { getJsTypeByTypeMs } from './ms/utils-ms';
+
+export { getInsertSqlMs } from './ms/get-sql/insert';
+
+export { getMergeSqlMs } from './ms/get-sql/merge';
+
+export { getUpdateSqlMs } from './ms/get-sql/update';
 
 export {
+  poolsCacheMs,
   getPoolConnectionMs,
   closeAllDbConnectionsMs,
   closeDbConnectionsAndExitMs,
   closeDbConnectionsMs,
   getDbConfigMs,
   getPoolMs,
-  poolsCacheMs,
-  closeAllDbConnections,
-  closeDbConnectionsAndExit,
-} from './mssql/pool-ms';
-
-export { queryMs } from './mssql/query-ms';
+} from './ms/pool-ms';
 
 export {
+  prepareSqlValueMs,
   prepareSqlStringMs,
+} from './ms/prepare-value';
+
+export { queryMs } from './ms/query-ms';
+
+export {
+  getTableSchemaMs,
   correctRecordSchemaMs,
-  getRecordSchemaMs,
-  wrapTransactionMs,
-  serializeMs,
-  getRecordValuesForSqlMs,
-  getSqlSetExpressionMs,
-  getSqlValuesExpressionMs,
-  prepareRecordForSqlMs,
-  prepareDataForSqlMs,
-  getRowsAffectedMs,
-  sql,
-} from './mssql/sql';
+} from './ms/table-schema-ms';
 
-export { mssqlEscape } from './mssql/utils';
+export { wrapTransactionMs } from './ms/wrap-transaction-ms';
 
-export { getMergeSqlPg } from './pg/get-merge-sql';
+// ######################### PG #####################################
 
-export { getUpdateSqlPg } from './pg/get-update-sql';
+export {
+  IFieldDefPg,
+  TColumnsSchemaPg,
+  ITableSchemaPg,
+  TUniqueConstraintsPg,
+  IPoolPg,
+  IConnectionPoolsPg,
+  IPoolClientPg,
+} from './@types/i-pg';
 
-export { insertPg, EUpdateLevel } from './pg/insert';
+export { TDataTypePg } from './@types/i-data-types-pg';
+
+export {
+  genTableInterfacePg,
+  genTableInterfacesPg,
+} from './pg/gen-table-interfaces-pg';
+
+export {
+  getJsTypeByTypePg,
+  getTypeByUdtNamePg,
+  getNormalizedTypePg,
+} from './pg/utils-pg';
+
+export { getInsertSqlPg } from './pg/get-sql/insert';
+
+export { getMergeSqlPg } from './pg/get-sql/merge';
+
+export { getUpdateSqlPg } from './pg/get-sql/update';
+
+export { insertPg, EUpdateLevel } from './pg/insert-pg';
 
 export { isTableOrViewExistsPg } from './pg/is-table-or-view-exists';
 
@@ -102,15 +143,16 @@ export {
   closePoolPg,
   getDbConfigPg,
   closeAllPgConnectionsPg,
-} from './pg/pg-pool';
+} from './pg/pool-pg';
 
-export { prepareSqlStringPg, prepareSqlValuePg } from './pg/prepare-value';
+export {
+  prepareSqlStringPg,
+  prepareSqlValuePg,
+} from './pg/prepare-value';
 
 export { queryPg } from './pg/query-pg';
 
-export { getFieldsAndValuesPg, getTableSchemaPg } from './pg/table-schema';
-
-export { closeAllDb, graceExit, logSqlError } from './common';
-
-export { setLogger } from './logger-error';
-export { schemaTable } from './utils';
+export {
+  getFieldsAndValuesPg,
+  getTableSchemaPg,
+} from './pg/table-schema-pg';

package/src/ms/gen-table-interfaces-ms.ts

@@ -0,0 +1,52 @@
+/* eslint-disable no-await-in-loop */
+import * as path from 'path';
+import * as fs from 'fs';
+import { echo } from 'af-echo-ts';
+import { IFieldDefMs } from '../@types/i-ms';
+import { getTableSchemaMs } from './table-schema-ms';
+import { closeAllDbConnectionsMs } from './pool-ms';
+import { schemaTable } from '../utils/utils';
+import { getJsTypeByTypeMs } from './utils-ms';
+
+const getFieldDefinition = (d: IFieldDefMs): string => {
+  const fieldName = d.name + (d.isNullable || d.hasDefault ? '?' : '');
+  return `${fieldName}: ${getJsTypeByTypeMs(d.dataType, d.arrayType)}${d.isNullable ? ' | null' : ''}`;
+};
+
+const TABLE_INTERFACES_DIR = __dirname.replace(/\\/g, '/').replace(/\/dist\//, '/');
+
+export const genTableInterfaceMs = async (
+  connectionId: string,
+  commonSchemaAndTable: string,
+  tableInterfacesDir: string = TABLE_INTERFACES_DIR,
+): Promise<void> => {
+  const tableSchema = await getTableSchemaMs(connectionId, commonSchemaAndTable);
+  const interfaceName = `I${schemaTable.to.common(commonSchemaAndTable)
+    .replace('.', '_')
+    .split('_')
+    .map((word) => word[0].toUpperCase() + word.substring(1))
+    .join('')}Record`;
+
+  const linesArr = Object.values(tableSchema.columnsSchema).map(getFieldDefinition);
+  const content = `export interface ${interfaceName} {\n${linesArr.map((v) => `  ${v}`).join(',\n')},\n}\n`;
+
+  const fileName = `${commonSchemaAndTable.replace('.', '-').toLowerCase()}.ts`;
+  const filePath = path.resolve(path.join(tableInterfacesDir, fileName));
+
+  fs.writeFileSync(filePath, content);
+};
+
+export const genTableInterfacesMs = async (
+  connectionId: string,
+  tables: string[],
+  tableInterfacesDir: string = TABLE_INTERFACES_DIR,
+): Promise<void> => {
+  for (let i = 0; i < tables.length; i++) {
+    const commonSchemaAndTable = tables[i];
+    await genTableInterfaceMs(connectionId, commonSchemaAndTable, tableInterfacesDir);
+  }
+  echo.g(`Generated ${tables.length} table interfaces in folder '.${
+    tableInterfacesDir.replace(process.cwd().replace(/\\/g, '/'), '')}/'`);
+  await closeAllDbConnectionsMs();
+  process.exit(0);
+};

package/src/ms/get-sql/insert.ts

@@ -0,0 +1,45 @@
+import { getTableSchemaMs } from '../table-schema-ms';
+import { prepareSqlValueMs } from '../prepare-value';
+import { ITableSchemaMs } from '../../@types/i-ms';
+import { TDBRecord, TRecordSet } from '../../@types/i-common';
+import { schemaTable } from '../../utils/utils';
+
+export const getInsertSqlMs = async <U extends TDBRecord = TDBRecord>(arg: {
+  connectionId: string,
+  commonSchemaAndTable: string,
+  recordset: TRecordSet<U>,
+  excludeFromInsert?: string[],
+  addOutputInserted?: boolean,
+}): Promise<string> => {
+  const { commonSchemaAndTable } = arg;
+
+  const tableSchema: ITableSchemaMs = await getTableSchemaMs(arg.connectionId, commonSchemaAndTable);
+  const { columnsSchema, fieldsWoSerialsAndRO, defaults } = tableSchema;
+
+  const insertFieldsArray = fieldsWoSerialsAndRO.filter((f) => (!(arg.excludeFromInsert || []).includes(f)));
+  const insertFieldsList = insertFieldsArray.map((f) => `[${f}]`).join(', ');
+
+  const preparedRowsArray = arg.recordset.map((record) => {
+    const preparedRecordValuesArray = insertFieldsArray.map((f) => {
+      const value = record[f];
+      const fieldDef = columnsSchema[f];
+      if (value != null) {
+        return prepareSqlValueMs({ value, fieldDef });
+      }
+      const defVal = defaults[f];
+      if (!fieldDef.isNullable && defVal != null) {
+        return defVal;
+      }
+      return 'NULL';
+    });
+    return preparedRecordValuesArray.join(',');
+  });
+
+  const values = preparedRowsArray.map((v) => `(${v})`).join('\n,');
+  const out = arg.addOutputInserted ? ' OUTPUT inserted.* ' : '';
+  const target = schemaTable.to.ms(commonSchemaAndTable);
+  // noinspection UnnecessaryLocalVariableJS
+  const insertSQL = `INSERT INTO ${target} (${insertFieldsList}) ${out}
+                     VALUES ${values};`;
+  return insertSQL;
+};

package/src/ms/get-sql/merge.ts

@@ -0,0 +1,118 @@
+import { getTableSchemaMs } from '../table-schema-ms';
+import { prepareSqlValueMs } from '../prepare-value';
+import { ITableSchemaMs } from '../../@types/i-ms';
+import { schemaTable } from '../../utils/utils';
+import { TDBRecord, TRecordSet } from '../../@types/i-common';
+
+export const getMergeSqlMs = async <U extends TDBRecord = TDBRecord> (arg: {
+  connectionId: string,
+  commonSchemaAndTable: string,
+  recordset: TRecordSet<U>,
+  omitFields?: string[],
+  excludeFromInsert?: string[],
+  noUpdateIfNull?: boolean,
+  withClause?: string,
+  mergeIdentity?: string[], // Список полей, по которым оценивается уникальность записи. По умолчанию - поля PK
+  noReturnMergeResult?: boolean,
+  mergeCorrection?: (_sql: string) => string,
+}): Promise<string> => {
+  const {
+    connectionId,
+    commonSchemaAndTable,
+    recordset,
+    omitFields = [],
+  } = arg;
+  if (!recordset?.length) {
+    return '';
+  }
+  const schemaTableStr = schemaTable.to.ms(commonSchemaAndTable);
+  const tableSchema: ITableSchemaMs = await getTableSchemaMs(connectionId, commonSchemaAndTable);
+  const { columnsSchema, pk, fieldsWoSerialsAndRO, defaults } = tableSchema;
+
+  let mergeFieldsArr: string[] = fieldsWoSerialsAndRO;
+  if (omitFields.length) {
+    const set = new Set(omitFields);
+    mergeFieldsArr = fieldsWoSerialsAndRO.filter((fieldName) => !set.has(fieldName));
+  }
+
+  const mergeValues = recordset.map((record: U) => {
+    const preparedValues: (string | number)[] = [];
+
+    mergeFieldsArr.forEach((f) => {
+      const value = record[f];
+      let sqlValue = prepareSqlValueMs({ value, fieldDef: columnsSchema[f] });
+      if (defaults[f] != null && (sqlValue == null || sqlValue === 'null')) {
+        sqlValue = defaults[f];
+      }
+      preparedValues.push(sqlValue);
+    });
+    return `(${preparedValues.join(', ')})`;
+  }).join(',\n    ').trim();
+
+  const { mergeIdentity = pk } = arg;
+  if (!mergeIdentity?.length) {
+    throw new Error(`The list of fields by which the uniqueness of a record is assessed is empty!`);
+  }
+  const onClause = mergeIdentity.map((f) => (`target.[${f}] = source.[${f}]`)).join(' AND ');
+
+  const updateFields = mergeFieldsArr.filter((f) => (!mergeIdentity.includes(f)));
+
+  const updateFieldsList = updateFields.map((f) => (`target.[${f}] = ${
+    arg.noUpdateIfNull
+      ? `COALESCE(source.[${f}], target.[${f}])`
+      : `source.[${f}]`
+  }`)).join(',\n    ');
+
+  const insertFieldsArray = mergeFieldsArr.filter((f) => (!(arg.excludeFromInsert || []).includes(f)));
+  const mergeFieldsList = mergeFieldsArr.map((f) => `[${f}]`).join(',\n    ');
+
+  const insertSourceList = insertFieldsArray.map((f) => (`source.[${f}]`)).join(',\n    ');
+  const insertFieldsList = insertFieldsArray.map((f) => `[${f}]`).join(',\n    ');
+
+  let mergeSQL = `MERGE ${schemaTableStr} ${arg.withClause || ''} AS target
+USING
+(
+  SELECT * FROM ( 
+    VALUES
+    ${mergeValues}
+  )
+  AS s (
+    ${mergeFieldsList}
+  )
+)
+AS source
+ON ${onClause}
+
+WHEN MATCHED THEN
+  UPDATE SET
+    ${updateFieldsList}
+
+WHEN NOT MATCHED THEN
+  INSERT (
+    ${insertFieldsList}
+  )
+  VALUES (
+    ${insertSourceList}
+  )`;
+
+  if (!arg.noReturnMergeResult) {
+    mergeSQL = `
+${'DECLARE'} @t TABLE ( act VARCHAR(20));
+DECLARE @total AS INTEGER;
+DECLARE @i AS INTEGER;
+DECLARE @u AS INTEGER;
+${mergeSQL}
+OUTPUT $action INTO @t;
+SET @total = @@ROWCOUNT;
+SELECT @i = COUNT(*) FROM @t WHERE act = 'INSERT';
+SELECT @u = COUNT(*) FROM @t WHERE act != 'INSERT';
+SELECT @total as total, @i as inserted, @u as updated;
+`;
+  } else {
+    mergeSQL += `;\n`;
+  }
+  if (typeof arg.mergeCorrection === 'function') {
+    mergeSQL = arg.mergeCorrection(mergeSQL);
+  }
+  return mergeSQL;
+};

package/src/ms/get-sql/update.ts

@@ -0,0 +1,46 @@
+import { getTableSchemaMs } from '../table-schema-ms';
+import { prepareSqlValueMs } from '../prepare-value';
+import { ITableSchemaMs } from '../../@types/i-ms';
+import { TDBRecord } from '../../@types/i-common';
+import { schemaTable } from '../../utils/utils';
+
+export const getUpdateSqlMs = async <U extends TDBRecord = TDBRecord>(arg: {
+  connectionId: string,
+  commonSchemaAndTable: string,
+  record: U,
+  customSets: TDBRecord,
+  updateIdentity?: string[],
+}): Promise<string> => {
+  const {
+    connectionId,
+    commonSchemaAndTable,
+    record,
+    customSets = {},
+  } = arg;
+  const tableSchema: ITableSchemaMs = await getTableSchemaMs(connectionId, commonSchemaAndTable);
+  const { columnsSchema, pk, fieldsWoSerialsAndRO } = tableSchema;
+
+  const { updateIdentity = pk } = arg;
+
+  const updateFields = fieldsWoSerialsAndRO.filter((f) => (!updateIdentity.includes(f)));
+
+  const getPreparedSqlValue = (f: string) => prepareSqlValueMs({ value: record[f], fieldDef: columnsSchema[f] });
+
+  const preparedRecord: TDBRecord = {};
+  updateFields.forEach((f) => {
+    if (customSets[f] !== undefined) {
+      preparedRecord[f] = customSets[f];
+    } else if (record[f] !== undefined) {
+      preparedRecord[f] = getPreparedSqlValue(f);
+    }
+  });
+  const sets = Object.entries(preparedRecord).map(([f, v]) => `[${f}] = ${v}`).join(', ');
+
+  const where = updateIdentity.map((f) => `[${f}] = ${getPreparedSqlValue(f)}`).join(' AND ');
+
+  // noinspection UnnecessaryLocalVariableJS
+  const updateSql = `${'UPDATE'} ${schemaTable.to.ms(commonSchemaAndTable)} SET
+    ${sets}
+  WHERE ${where};`;
+  return updateSql;
+};

package/src/{mssql → ms}/pool-ms.ts

@@ -157,14 +157,6 @@ export const closeDbConnectionsMs = async (poolsToClose: ConnectionPool | Connec
   }
 };
 
-/**
- * @deprecated since version 2.0.0
- */
-export const closeAllDbConnections = async (prefix?: string, noEcho?: boolean) => {
-  const poolsToClose = Object.values(poolsCacheMs);
-  await closeDbConnectionsMs(poolsToClose, prefix, noEcho);
-};
-
 /**
  * Закрывает все соединения с БД
  *
@@ -176,14 +168,6 @@ export const closeAllDbConnectionsMs = async (prefix?: string, noEcho?: boolean)
   await closeDbConnectionsMs(poolsToClose, prefix, noEcho);
 };
 
-/**
- * @deprecated since version 2.0.0
- */
-export const closeDbConnectionsAndExit = async (poolsToClose: ConnectionPool | ConnectionPool[], prefix?: string) => {
-  await closeDbConnectionsMs(poolsToClose, prefix);
-  process.exit(0);
-};
-
 /**
  * Закрывает указанные соединения с БД и прерывает работу скрипта
  *