dbmodel 0.1.1 → 5.2.2-alpha.11

package/lib/clients/mssql/load.js

@@ -1,210 +0,0 @@
-const _ = require('lodash');
-const query = require('./query');
-
-function extractCamelCaseResult(result) {
-  return result.map(x => _.mapKeys(x, (v, k) => _.camelCase(k)));
-}
-
-async function loadColumnsByTablesFromDatabase(options) {
-  const result = await query(
-    options,
-    `
-  select c.name as column_name, t.name as type_name, c.object_id, c.is_identity,
-	c.max_length, c.precision, c.scale, c.is_nullable,
-	d.definition as default_value, d.name as default_constraint,
-  m.definition as computed_expression, m.is_persisted, c.column_id,
-  o.name as table_name, ic.character_maximum_length
-from sys.columns c
-inner join sys.types t on c.system_type_id = t.system_type_id and c.user_type_id = t.user_type_id
-inner join sys.objects o on c.object_id = o.object_id
-inner join sys.schemas u on u.schema_id = o.schema_id
-left join sys.default_constraints d on c.default_object_id = d.object_id
-left join sys.computed_columns m on m.object_id = c.object_id and m.column_id = c.column_id
-inner join information_schema.columns ic on ic.table_name = o.name and ic.column_name = c.name and ic.table_schema='dbo'
-where o.type = 'U' and u.name = 'dbo'
-order by c.column_id
-`
-  );
-  const columns = extractCamelCaseResult(result);
-  return _.groupBy(columns, 'tableName');
-}
-
-async function loadIndexesByTablesFromDatabase(options) {
-  const result = await query(
-    options,
-    `select 
-  i.object_id, 
-  i.name as index_name, 
-  i.type_desc, 
-  i.is_unique,
-  i.index_id, 
-  i.is_unique_constraint, 
-  i.filter_definition,
-  c.name as column_name,
-  ic.key_ordinal,
-  ic.is_included_column,
-  o.name as table_name
-from sys.indexes i
-inner join sys.index_columns ic on i.index_id = ic.index_id and i.object_id = ic.object_id
-inner join sys.columns c ON c.object_id = i.object_id and c.column_id = ic.column_id
-inner join sys.objects o ON o.object_id = i.object_id
-where i.is_primary_key=0
-and i.is_hypothetical=0 and indexproperty(i.object_id, i.name, 'IsStatistics') = 0
-and objectproperty(i.object_id, 'IsUserTable') = 1
-and i.index_id between 1 and 254
-order by ic.key_ordinal`
-  );
-  const columns = extractCamelCaseResult(result);
-  const columnsByTable = _.groupBy(columns, 'tableName');
-  const indexesByTable = _.mapValues(columnsByTable, cols => _.groupBy(cols, 'indexName'));
-  const indexesByTable2 = _.mapValues(indexesByTable, tableIndexes =>
-    _.mapValues(tableIndexes, columns => ({
-      ..._.pick(columns[0], ['tableName', 'indexName', 'isUnique', 'filterDefinition']),
-      columns: columns.map(x => _.pick(x, ['columnName', 'isIncludedColumn'])),
-    }))
-  );
-  return indexesByTable2;
-}
-
-async function loadViewsFromDatabase(options) {
-  const result = await query(options, `select * from information_schema.views where TABLE_SCHEMA = 'dbo'`);
-  return _.mapValues(_.keyBy(extractCamelCaseResult(result), 'tableName'), 'viewDefinition');
-}
-
-async function loadRoutinesFromDatabase(options) {
-  const result = await query(
-    options,
-    `select s.name as ROUTINE_NAME, u.name as ROUTINE_SCHEMA, c.text AS ROUTINE_DEFINITION, LTRIM(RTRIM(s.type)) AS ROUTINE_TYPE
-  from sys.objects s
-  inner join sys.syscomments c on s.object_id = c.id
-  inner join sys.schemas u on u.schema_id = s.schema_id
-  where u.name='dbo'
-  order by u.name, s.name, c.colid
-  `
-  );
-  const camelCaseResult = extractCamelCaseResult(result);
-  const functionsArray = camelCaseResult.filter(
-    x => x.routineType == 'IF' || x.routineType == 'FN' || x.routineType == 'TF'
-  );
-  const proceduresArray = camelCaseResult.filter(x => x.routineType == 'P');
-  return {
-    functions: _.mapValues(_.groupBy(functionsArray, 'routineName'), x => x.map(y => y.routineDefinition).join('')),
-    procedures: _.mapValues(_.groupBy(proceduresArray, 'routineName'), x => x.map(y => y.routineDefinition).join('')),
-  };
-}
-
-async function loadReferencesFromDatabase(options) {
-  const result = await query(
-    options,
-    `SELECT
-  fkSchema = FK.TABLE_SCHEMA,
-  fkTable = FK.TABLE_NAME,
-  fkColumn = CU.COLUMN_NAME,
-  
-  pkSchema = PK.TABLE_SCHEMA,
-  pkTable = PK.TABLE_NAME,
-  
-  constraintName = C.CONSTRAINT_NAME
-  
-  FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C
-  INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK 
-    ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME AND c.CONSTRAINT_SCHEMA = FK.CONSTRAINT_SCHEMA
-  LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK 
-    ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME AND c.UNIQUE_CONSTRAINT_SCHEMA = PK.CONSTRAINT_SCHEMA
-  LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU 
-    ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME AND C.CONSTRAINT_SCHEMA = CU.CONSTRAINT_SCHEMA
-  WHERE c.CONSTRAINT_SCHEMA = 'dbo'
-  `
-  );
-  return result;
-}
-
-async function loadPrimaryKeysFromDatabase(options) {
-  const result = await query(
-    options,
-    `select key_column_usage.table_name, key_column_usage.column_name from information_schema.table_constraints
-  inner join information_schema.key_column_usage on key_column_usage.constraint_name = table_constraints.constraint_name and key_column_usage.constraint_schema = table_constraints.constraint_schema
-  where constraint_type = 'PRIMARY KEY' and table_constraints.constraint_schema = 'dbo'
-  order by ordinal_position
-  `
-  );
-  return _(result)
-    .groupBy('table_name')
-    .mapValues(x => _.map(x, 'column_name'))
-    .value();
-}
-
-function parseLogicalModel({ tables, primaryKeys, references, views, procedures, functions, indexes }) {
-  const resTables = {};
-  for (const table of Object.keys(tables)) {
-    let columns = tables[table];
-    const resTable = { name: table, columns: [] };
-    resTables[table] = resTable;
-    for (const column of columns) {
-      const resColumn = {
-        name: column.columnName,
-        type: column.typeName,
-      };
-      if (column.characterMaximumLength) resColumn.length = column.characterMaximumLength;
-      if (column.isIdentity) resColumn.autoIncrement = true;
-      if (!column.isNullable) resColumn.notNull = true;
-
-      const refColumn = references.find(x => x.fkTable == table && x.fkColumn == column.columnName);
-      if (refColumn) {
-        resColumn.references = refColumn.pkTable;
-      }
-      resTable.columns.push(resColumn);
-    }
-    if (table in primaryKeys) {
-      resTable.primaryKey = primaryKeys[table];
-    }
-    if (table in indexes) {
-      resTable.indexes = [];
-
-      for (const { indexName, isUnique, columns } of Object.values(indexes[table])) {
-        const resIndex = {
-          name: indexName,
-          unique: isUnique,
-          columns: columns.map(x => x.columnName),
-        };
-        resTable.indexes.push(resIndex);
-      }
-    }
-  }
-
-  return {
-    tables: resTables,
-    views,
-    procedures,
-    functions,
-  };
-}
-
-async function load(options) {
-  const tables = await loadColumnsByTablesFromDatabase(options);
-  console.log(`Loaded ${Object.keys(tables).length} tables`);
-  const primaryKeys = await loadPrimaryKeysFromDatabase(options);
-  console.log(`Loaded ${Object.keys(primaryKeys).length} primary keys`);
-  const references = await loadReferencesFromDatabase(options);
-  console.log(`Loaded ${references.length} references`);
-  const views = await loadViewsFromDatabase(options);
-  console.log(`Loaded ${Object.keys(views).length} views`);
-  const { procedures, functions } = await loadRoutinesFromDatabase(options);
-  console.log(`Loaded ${Object.keys(procedures).length} procedures and ${Object.keys(functions).length} functions`);
-  const indexes = await loadIndexesByTablesFromDatabase(options);
-  console.log(`Loaded indexes for ${Object.keys(indexes).length} tables`);
-
-  const mssqlModel = {
-    tables,
-    primaryKeys,
-    references,
-    views,
-    procedures,
-    functions,
-    indexes,
-  };
-  const logicalModel = parseLogicalModel(mssqlModel);
-  return { ...logicalModel, mssqlModel };
-}
-
-module.exports = load;

package/lib/clients/mssql/query.js

@@ -1,6 +0,0 @@
-async function query({ mssqlPool }, sql) {
-  const result = await mssqlPool.request().query(sql);
-  return result.recordset;
-}
-
-module.exports = query;

package/lib/connect.js

@@ -1,8 +0,0 @@
-async function connect(options) {
-  const { client } = options;
-  const connectFunc = require(`./clients/${client}/connect`);
-  await connectFunc(options);
-  return options;
-}
-
-module.exports = connect;

package/lib/deploy.js

@@ -1,22 +0,0 @@
-const read = require('./read');
-const load = require('./load');
-const connect = require('./connect');
-const runHooks = require('./hooks/runHooks');
-
-async function deploy(options) {
-  const { client } = options;
-
-  options = await connect(options);
-  options = await read(options);
-  options = await load(options);
-
-  const deployFunc = require(`./clients/${client}/deploy`);
-
-  runHooks(options, 'before-deploy');
-  await deployFunc(options);
-  runHooks(options, 'after-deploy');
-
-  return options;
-}
-
-module.exports = deploy;

package/lib/dump.js

@@ -1,38 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const yaml = require('js-yaml');
-
-const load = require('./load');
-
-async function dump(options) {
-  try {
-    const { outputDir } = options;
-    const { databaseStructure } = await load(options);
-    const { tables, views, procedures, functions } = databaseStructure;
-
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir);
-    }
-
-    for (const table of Object.keys(tables)) {
-      const content = yaml.dump(tables[table]);
-      fs.writeFileSync(path.join(outputDir, table + '.table.yaml'), content);
-    }
-
-    for (const view of Object.keys(views)) {
-      fs.writeFileSync(path.join(outputDir, view + '.view.sql'), views[view]);
-    }
-
-    for (const procedure of Object.keys(procedures)) {
-      fs.writeFileSync(path.join(outputDir, procedure + '.proc.sql'), procedures[procedure]);
-    }
-
-    for (const func of Object.keys(functions)) {
-      fs.writeFileSync(path.join(outputDir, func + '.func.sql'), functions[func]);
-    }
-  } catch (err) {
-    console.log('dbmodel error: ', err);
-  }
-}
-
-module.exports = dump;

package/lib/efmodel.js

@@ -1,132 +0,0 @@
-// generate EntityFramework Core model
-
-const _ = require('lodash');
-const fs = require('fs');
-const read = require('./read');
-
-function getDotNetType(type) {
-  if (!type) return null;
-  if (type.includes('char')) return 'string';
-  if (type.includes('bigint')) return 'long';
-  if (type.includes('int')) return 'int';
-  if (type.includes('date')) return 'DateTime';
-  if (type.includes('decimal')) return 'decimal';
-  if (type.includes('bit')) return 'bool';
-  if (type === 'json') return 'string';
-  return null;
-}
-
-function getDotNetName(name) {
-  if (name === 'params') return '@params';
-  return name;
-}
-
-async function efmodel(options) {
-  const { outputFile } = options;
-  const { projectStructure, namespaceName, contextClassName } = await read(options);
-
-  const { tables } = projectStructure;
-
-  let s = '';
-  s += 'using System;\n';
-  s += 'using Microsoft.EntityFrameworkCore;\n';
-  s += 'using System.ComponentModel.DataAnnotations.Schema;\n';
-  s += 'using System.Collections.Generic;\n';
-  s += 'using Newtonsoft.Json;\n';
-
-  s += `namespace ${namespaceName} {\n`;
-  s += `    partial class ${contextClassName} { \n`;
-  for (const tableName of Object.keys(tables)) {
-    s += `        public DbSet<Db${tableName}> ${tableName} { get; set; }\n`;
-  }
-
-  s += '        protected override void OnModelCreating(ModelBuilder modelBuilder)\n';
-  s += '        {\n';
-  for (const tableName of Object.keys(tables)) {
-    const table = tables[tableName];
-    s += `            modelBuilder.Entity<Db${tableName}>().HasKey(o=>new {${table.primaryKey
-      .map(t => `o.${t}`)
-      .join(', ')} });\n`;
-  }
-  s += '        }\n';
-  s += '    }\n';
-
-  for (const tableName of Object.keys(tables)) {
-    const table = tables[tableName];
-    const { columns, data } = table;
-
-    const bases = [];
-    const enumDef = table['enum'];
-
-    if (options.getEntityBaseClass) {
-      const optionBase = options.getEntityBaseClass(table);
-      if (_.isString(optionBase)) bases.push(optionBase);
-      else if (_.isArray(optionBase)) bases.push(...optionBase);
-    }
-    s += `    public partial class Db${tableName} ${bases.length > 0 ? ':' : ''}  ${bases.join(',')} {\n`;
-
-    if (enumDef) {
-      for (const dataRow of data) {
-        s += `        public const int ${_.camelCase(dataRow[enumDef.name])} = ${dataRow[enumDef.value]};\n`;
-      }
-      s += `         public static Dictionary<string, int> keyToInt = new Dictionary<string, int>();\n`;
-      s += `         public static Dictionary<int, string> intToKey = new Dictionary<int, string>();\n`;
-    }
-
-    s += `        static Db${tableName}() {\n`;
-    if (enumDef) {
-      for (const dataRow of data) {
-        s += `            keyToInt["${dataRow[enumDef.name]}"] = ${dataRow[enumDef.value]};\n`;
-        s += `            intToKey[${dataRow[enumDef.value]}] = "${dataRow[enumDef.name]}";\n`;
-      }
-    }
-    s += `        }\n`;
-
-    s += `        public Db${tableName} Duplicate() {\n`;
-    s += `            var res = new Db${tableName}();\n`;
-    for (const column of columns) {
-      const { name } = column;
-      if (options.getEntityDuplicateColumnFilter == null || options.getEntityDuplicateColumnFilter(name)) {
-        s += `            res.${getDotNetName(name)} = ${getDotNetName(name)};\n`;
-      }
-    }
-    s += `            return res;\n`;
-    s += `        }\n`;
-
-    for (const column of columns) {
-      const { type, notNull, name: colname, references } = column;
-      let defaultValue = column['default'];
-      const dotNetType = getDotNetType(type);
-      if (dotNetType === 'bool' && defaultValue != null) defaultValue = defaultValue ? 'true' : 'false';
-
-      if (dotNetType) {
-        s += `        public ${dotNetType}${notNull ? '' : '?'} ${getDotNetName(colname)} {get; set; }`;
-        if (defaultValue) s += ` = ${defaultValue};`;
-        s += '\n';
-      }
-      if (references) {
-        s += `        [ForeignKey("${colname}")]\n`;
-        s += `        [JsonIgnore]\n`;
-        s += `        public Db${references}${notNull ? '' : '?'} ${colname}Ref {get; set; }\n`;
-      }
-    }
-
-    for (const otherTableName of Object.keys(tables)) {
-      const otherTable = tables[otherTableName];
-      const { columns: otherColumns } = otherTable;
-      for (const otherColumn of otherColumns) {
-        if (otherColumn.references === tableName) {
-          s += `        [InverseProperty("${otherColumn.name}Ref")]\n`;
-          s += `        [JsonIgnore]\n`;
-          s += `        public List<Db${otherTableName}> ${otherColumn.name}${otherTableName}List {get; set; }\n`;
-        }
-      }
-    }
-
-    s += '    }\n';
-  }
-  s += '}\n';
-  fs.writeFileSync(outputFile, s);
-}
-
-module.exports = efmodel;

package/lib/hooks/autoIndexForeignKeys.js

@@ -1,23 +0,0 @@
-async function autoIndexForeignKeys(options, event) {
-  if (event !== 'before-deploy' && event !== 'before-build') return;
-
-  const { projectStructure } = options;
-  if (!projectStructure) return;
-  const { tables } = projectStructure;
-  if (!tables) return;
-
-  for (const tableName of Object.keys(tables)) {
-    const table = tables[tableName];
-    for (const column of table.columns) {
-      if (column.references) {
-        if (!table.indexes) table.indexes = [];
-        table.indexes.push({
-          name: `IX_FK_${tableName}_${column.name}`,
-          columns: [column.name],
-        });
-      }
-    }
-  }
-}
-
-module.exports = autoIndexForeignKeys;

package/lib/hooks/index.js

@@ -1,3 +0,0 @@
-const autoIndexForeignKeys = require('./autoIndexForeignKeys');
-
-module.exports = { autoIndexForeignKeys };

package/lib/hooks/runHooks.js

@@ -1,10 +0,0 @@
-async function runHooks(options, event) {
-  const { hooks } = options;
-  if (hooks) {
-    for (const hook of hooks) {
-      await hook(options, event);
-    }
-  }
-}
-
-module.exports = runHooks;

package/lib/index.js

@@ -1,20 +0,0 @@
-const load = require('./load');
-const connect = require('./connect');
-const dump = require('./dump');
-const deploy = require('./deploy');
-const build = require('./build');
-const efmodel = require('./efmodel');
-
-const hooks = require('./hooks');
-const runAndExit = require('./runAndExit');
-
-module.exports = {
-  load,
-  connect,
-  dump,
-  deploy,
-  hooks,
-  build,
-  efmodel,
-  runAndExit,
-};

package/lib/load.js

@@ -1,22 +0,0 @@
-const _ = require('lodash');
-const connect = require('./connect');
-const query = require('./query');
-
-async function load(options) {
-  await connect(options);
-  const { client } = options;
-  const loadFunc = require(`./clients/${client}/load`);
-  options.databaseStructure = await loadFunc(options);
-  if (options.loadDataCondition) {
-    const { tables } = options.databaseStructure;
-    for (const tableName of _.keys(tables)) {
-      const table = tables[tableName];
-      if (!options.loadDataCondition(table)) continue;
-      const data = await query(options, `SELECT * FROM [${tableName}]`);
-      table.data = data;
-    }
-  }
-  return options;
-}
-
-module.exports = load;

package/lib/query.js

@@ -1,7 +0,0 @@
-async function query(options, sql) {
-  const { client } = options;
-  const queryFunc = require(`./clients/${client}/query`);
-  return await queryFunc(options, sql);
-}
-
-module.exports = query;

package/lib/read.js

@@ -1,61 +0,0 @@
-const _ = require('lodash');
-const readdirSyncRecursive = require('fs-readdir-recursive');
-const yaml = require('js-yaml');
-const path = require('path');
-const fs = require('fs');
-
-function readTablesFromDirectory(directory) {
-  const files = readdirSyncRecursive(directory);
-  const tables = _.keyBy(
-    files
-      .filter(x => x.endsWith('.table.yaml'))
-      .map(file => yaml.safeLoad(fs.readFileSync(path.join(directory, file)))),
-    'name'
-  );
-  return tables;
-}
-
-function escapeRegExp(str) {
-  return str.replace(/([.*+?^=!:${}()|[\]/\\])/g, '\\$1');
-}
-
-function processReplacements(value, replacements) {
-  if (!replacements) return value;
-  return Object.keys(replacements).reduce(
-    (acc, key) => acc.replace(new RegExp(escapeRegExp(key), 'g'), replacements[key]),
-    value
-  );
-}
-
-function readObjectsFromDirectory(directory, extension, replacements) {
-  const files = readdirSyncRecursive(directory).filter(x => x.endsWith(extension));
-  const views = files.map(file =>
-    processReplacements(fs.readFileSync(path.join(directory, file)).toString(), replacements)
-  );
-  return _.zipObject(
-    files.map(name => {
-      const res = name.slice(0, -extension.length);
-      const max = Math.max(res.lastIndexOf('/'), res.lastIndexOf('\\'));
-      if (max > 0) return res.substring(max + 1);
-      return res;
-    }),
-    views
-  );
-}
-
-async function read(options) {
-  const { projectDir, replacements } = options;
-  const tables = readTablesFromDirectory(projectDir);
-  const views = readObjectsFromDirectory(projectDir, '.view.sql', replacements);
-  const procedures = readObjectsFromDirectory(projectDir, '.proc.sql', replacements);
-  const functions = readObjectsFromDirectory(projectDir, '.func.sql', replacements);
-  options.projectStructure = {
-    tables,
-    views,
-    procedures,
-    functions,
-  };
-  return options;
-}
-
-module.exports = read;

package/lib/runAndExit.js

@@ -1,13 +0,0 @@
-async function runAndExit(promise) {
-  try {
-    await promise;
-    console.log('SUCCESS');
-    process.exit();
-  } catch (e) {
-    console.log('ERROR');
-    console.log(e);
-    process.exit(1);
-  }
-}
-
-module.exports = runAndExit;