sasat 0.21.21 → 0.22.0

package/dist/shared/sasat.CFfsuShk.mjs

@@ -1,398 +0,0 @@
-import SqlString__default from 'sqlstring';
-import * as mysql from 'mysql2';
-import { promisify } from 'util';
-import path__default, { join } from 'path';
-import fs from 'fs-extra';
-import yaml from 'js-yaml';
-
-const { escapeId, escape } = SqlString__default;
-const SqlString = {
-  escape: (value) => escape(value, true),
-  escapeId: (name) => escapeId(name)
-};
-
-const assignDeep = (base, ...objects) => {
-  const assign = (target, key, value) => {
-    if (key === "__proto__" || key === "constructor") {
-      return;
-    }
-    if (Array.isArray(target[key]) && Array.isArray(value)) {
-      target[key] = [...target[key], ...value];
-    } else if (typeof target[key] === "object" && typeof value === "object") {
-      assignDeep(target[key], value);
-    } else {
-      target[key] = value;
-    }
-  };
-  objects.forEach((obj) => {
-    if (typeof obj === "object") {
-      Object.entries(obj).forEach(([key, value]) => {
-        assign(base, key, value);
-      });
-    }
-  });
-  return base;
-};
-
-const readYmlFile = (filepath) => yaml.load(fs.readFileSync(filepath, "utf8"));
-const mkDirIfNotExist = (path) => {
-  if (!fs.pathExistsSync(path)) fs.mkdirpSync(path);
-};
-const writeFileIfNotExist = (path, data) => {
-  if (fs.existsSync(path)) return Promise.resolve();
-  return fs.writeFile(path, data);
-};
-const writeYmlFile = (path, fileName, obj) => {
-  mkDirIfNotExist(path);
-  fs.writeFileSync(
-    join(path, fileName),
-    yaml.dump(obj, {
-      skipInvalid: true,
-      noRefs: true,
-      sortKeys: (a, b) => {
-        if (b === "tableName") return 1;
-        if (a === "tableName") return -1;
-        if (a > b) return 1;
-        if (a < b) return -1;
-        return 0;
-      }
-    })
-  );
-};
-const readInitialSchema = () => {
-  return readYmlFile(join(config().migration.dir, "initialSchema.yml"));
-};
-const writeCurrentSchema = (schema) => {
-  writeYmlFile(config().migration.dir, "currentSchema.yml", schema);
-};
-
-class SasatConfigLoader {
-  static loadConfig() {
-    const fileName = "sasat.yml";
-    const filepath = path__default.join(process.cwd(), fileName);
-    if (!fs.existsSync(filepath)) return defaultConf;
-    return readYmlFile(filepath);
-  }
-  conf;
-  constructor() {
-    const conf = this.readValue({
-      ...defaultConf,
-      ...SasatConfigLoader.loadConfig()
-    });
-    this.conf = {
-      ...conf
-    };
-  }
-  getConfig() {
-    return this.conf;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  readValue(value) {
-    if (!value) return value;
-    if (Array.isArray(value)) return value.map((it) => this.readValue(it));
-    if (typeof value === "string" && value.startsWith("$"))
-      return process.env[value.slice(1)];
-    if (typeof value === "object") {
-      for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key))
-          value[key] = this.readValue(value[key]);
-      }
-      return value;
-    }
-    return value;
-  }
-}
-
-const defaultConfDb = {
-  host: "127.0.0.1",
-  port: 3306,
-  user: "root",
-  database: "sasat",
-  password: ""
-};
-const defaultConfMigration = {
-  table: "__migrate__",
-  dir: "migrations",
-  out: "sasat"
-};
-const defaultConf = {
-  db: defaultConfDb,
-  migration: defaultConfMigration,
-  generator: {
-    addJsExtToImportStatement: false,
-    gql: {
-      subscription: true
-    }
-  }
-  // redis: defaultCofRedis,
-};
-let conf;
-const config = () => {
-  if (conf === void 0) conf = new SasatConfigLoader().getConfig();
-  return conf;
-};
-function setConfig(update) {
-  conf = assignDeep(config(), update);
-  return conf;
-}
-
-const formatQuery = (str, ...params) => {
-  let ret = str[0];
-  for (let i = 0; i < params.length; i++) {
-    if (typeof params[i] === "function") ret += params[i]();
-    else if (Array.isArray(params[i]))
-      ret += params[i].map((it) => SqlString.escape(it)).join(", ");
-    else ret += SqlString.escape(params[i]);
-    ret += str[i + 1];
-  }
-  return ret;
-};
-
-const parent = (field2) => ({
-  kind: "parent",
-  field: field2
-});
-const child = (field2) => ({
-  kind: "child",
-  field: field2
-});
-const contextOrError = (field2, errorMessage) => ({
-  kind: "context",
-  field: field2,
-  onNotDefined: {
-    action: "error",
-    message: errorMessage
-  }
-});
-const contextOrDefault = (field2, defaultValue) => ({
-  kind: "context",
-  field: field2,
-  onNotDefined: {
-    action: "defaultValue",
-    value: defaultValue
-  }
-});
-const fixed = (value) => ({
-  kind: "fixed",
-  value
-});
-const today = (thresholdHour, date) => ({
-  kind: "today",
-  type: date ? "date" : "datetime",
-  thresholdHour
-});
-const now = () => ({
-  kind: "now"
-});
-const values = (begin, end) => ({
-  kind: "range",
-  begin,
-  end
-});
-const betweenToday = (thresholdHour) => ({
-  kind: "date-range",
-  range: "today",
-  thresholdHour
-});
-const custom = (conditionName, parentRequiredFields, childRequiredFields) => ({
-  kind: "custom",
-  conditionName,
-  parentRequiredFields,
-  childRequiredFields
-});
-const field = (column) => ({
-  kind: "field",
-  column
-});
-const arg = (name, type) => ({
-  kind: "arg",
-  name,
-  type
-});
-const betweenRel = (left, range) => ({
-  kind: "comparison",
-  left,
-  operator: "BETWEEN",
-  right: range
-});
-const betweenQuery = (left, begin, end) => ({
-  kind: "between",
-  operator: "BETWEEN",
-  left,
-  begin,
-  end
-});
-const comparisonRel = (left, operator, right) => ({
-  kind: "comparison",
-  left,
-  right,
-  operator
-});
-const inRel = (left, right) => ({
-  kind: "comparison",
-  left,
-  right,
-  operator: "IN"
-});
-const isNullRel = (value) => ({
-  kind: "isNull",
-  value,
-  not: false
-});
-const isNotNullRel = (value) => ({
-  kind: "isNull",
-  value,
-  not: true
-});
-const comparisonQuery = (left, operator, right) => ({
-  kind: "comparison",
-  left,
-  right,
-  operator
-});
-const Conditions = {
-  betweenRel,
-  betweenQuery,
-  custom,
-  rel: {
-    between: betweenRel,
-    comparison: comparisonRel,
-    in: inRel,
-    isNull: isNullRel,
-    isNotNull: isNotNullRel
-  },
-  query: {
-    between: betweenQuery,
-    comparison: comparisonQuery
-  },
-  value: {
-    parent,
-    child,
-    contextOrError,
-    contextOrDefault,
-    fixed,
-    today,
-    now,
-    field,
-    arg
-  },
-  range: {
-    values,
-    today: betweenToday
-  }
-};
-
-const pick = (target, keys) => Object.fromEntries(keys.map((key) => [key, target[key]]));
-const unique = (array) => {
-  const result = [];
-  for (let i = 0, l = array.length; i < l; i += 1) {
-    if (!result.includes(array[i])) {
-      result.push(array[i]);
-    }
-  }
-  return result;
-};
-const nonNullable = (value) => value != null;
-
-const noop = () => {
-};
-class SQLClient {
-  logger = noop;
-  rawQuery(sql) {
-    this.logger(sql);
-    return this.execSql(sql);
-  }
-  rawCommand(sql) {
-    this.logger(sql);
-    return this.execSql(sql);
-  }
-  query(templateString, ...params) {
-    return this.rawQuery(formatQuery(templateString, ...params));
-  }
-  command(templateString, ...params) {
-    return this.rawCommand(formatQuery(templateString, ...params));
-  }
-}
-class SQLTransaction extends SQLClient {
-}
-class DBClient extends SQLClient {
-  _released;
-  constructor(logger = noop) {
-    super();
-    this._released = false;
-    this.logger = logger;
-  }
-  isReleased() {
-    return this._released;
-  }
-}
-
-class MySqlTransaction extends SQLTransaction {
-  constructor(connection) {
-    super();
-    this.connection = connection;
-  }
-  commit() {
-    const result = promisify(this.connection.commit).bind(this.connection)();
-    this.connection.end();
-    return result;
-  }
-  async rollback() {
-    await promisify(this.connection.rollback).bind(this.connection)();
-    this.connection.end();
-    return;
-  }
-  execSql(sql) {
-    return promisify(this.connection.query).bind(this.connection)(
-      sql
-    );
-  }
-}
-
-class MysqlClient extends DBClient {
-  constructor(connectionOption, poolOption, logger) {
-    super(logger);
-    this.connectionOption = connectionOption;
-    this.pool = mysql.createPool({
-      ...config().db,
-      dateStrings: true,
-      ...connectionOption,
-      ...poolOption
-    });
-    this.release = this.release.bind(this);
-  }
-  pool;
-  async transaction() {
-    const connection = mysql.createConnection({
-      ...config().db,
-      dateStrings: true,
-      ...this.connectionOption
-    });
-    await promisify(connection.beginTransaction).bind(connection)();
-    return new MySqlTransaction(connection);
-  }
-  async release() {
-    await promisify(this.pool.end).bind(this.pool)();
-    this._released = true;
-  }
-  execSql(sql) {
-    return promisify(this.pool.query).bind(this.pool)(sql);
-  }
-}
-
-let client;
-const getDbClient = (...config) => {
-  if (client && !client.isReleased()) return client;
-  client = new MysqlClient(...config);
-  return client;
-};
-
-class SasatError extends Error {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, new.target.prototype);
-    this.name = "SasatError";
-  }
-}
-
-export { Conditions as C, SqlString as S, SasatError as a, assignDeep as b, config as c, writeCurrentSchema as d, writeYmlFile as e, formatQuery as f, getDbClient as g, defaultConf as h, mkDirIfNotExist as m, nonNullable as n, pick as p, readInitialSchema as r, setConfig as s, unique as u, writeFileIfNotExist as w };