@tachybase/database 0.23.8

package/lib/value-parsers/string-value-parser.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var string_value_parser_exports = {};
+__export(string_value_parser_exports, {
+  StringValueParser: () => StringValueParser
+});
+module.exports = __toCommonJS(string_value_parser_exports);
+var import_base_value_parser = require("./base-value-parser");
+const _StringValueParser = class _StringValueParser extends import_base_value_parser.BaseValueParser {
+  async setValue(value) {
+    const { map, set } = this.getOptions();
+    if (set.size > 0) {
+      if (map.has(value)) {
+        value = map.get(value);
+      }
+      if (set.has(value)) {
+        this.value = value;
+      } else {
+        this.errors.push(`No matching option found - ${JSON.stringify(value)}`);
+      }
+    } else {
+      this.value = value;
+    }
+  }
+  getOptions() {
+    var _a, _b;
+    const options = ((_b = (_a = this.field.options) == null ? void 0 : _a["uiSchema"]) == null ? void 0 : _b.enum) || [];
+    const map = /* @__PURE__ */ new Map();
+    const set = /* @__PURE__ */ new Set();
+    for (const option of options) {
+      if (typeof option === "string") {
+        set.add(option);
+        map.set(option, option);
+      } else {
+        set.add(option.value);
+        set.add(option.label);
+        map.set(option.label, option.value);
+      }
+    }
+    return { map, set };
+  }
+};
+__name(_StringValueParser, "StringValueParser");
+let StringValueParser = _StringValueParser;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringValueParser
+});

package/lib/value-parsers/to-many-value-parser.d.ts

@@ -0,0 +1,13 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class ToManyValueParser extends BaseValueParser {
+    setAccessors: {
+        attachment: string;
+        chinaRegion: string;
+    };
+    setAttachments(value: any): Promise<void>;
+    setChinaRegion(value: any): Promise<void>;
+    setAssociations(value: any): Promise<void>;
+    setValue(value: any): Promise<void>;
+    getInterface(): string;
+    isInterface(name: string): boolean;
+}

package/lib/value-parsers/to-many-value-parser.js

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var to_many_value_parser_exports = {};
+__export(to_many_value_parser_exports, {
+  ToManyValueParser: () => ToManyValueParser
+});
+module.exports = __toCommonJS(to_many_value_parser_exports);
+var import_path = require("path");
+var import_base_value_parser = require("./base-value-parser");
+const _ToManyValueParser = class _ToManyValueParser extends import_base_value_parser.BaseValueParser {
+  setAccessors = {
+    attachment: "setAttachments",
+    chinaRegion: "setChinaRegion"
+  };
+  async setAttachments(value) {
+    this.value = this.toArr(value).map((url) => {
+      return {
+        title: (0, import_path.basename)(url),
+        extname: (0, import_path.extname)(url),
+        filename: (0, import_path.basename)(url),
+        url
+      };
+    });
+  }
+  async setChinaRegion(value) {
+    const repository = this.field.database.getRepository(this.field.target);
+    try {
+      const values = [];
+      const names = this.toArr(value, "/");
+      let parentCode = null;
+      for (const name of names) {
+        const instance = await repository.findOne({
+          filter: {
+            name: name.trim(),
+            parentCode
+          }
+        });
+        if (!instance) {
+          throw new Error(`"${value}" does not exist`);
+        }
+        parentCode = instance.get("code");
+        values.push(parentCode);
+      }
+      if (values.length !== names.length) {
+        throw new Error(`"${value}" does not exist`);
+      }
+      this.value = values;
+    } catch (error) {
+      this.errors.push(error.message);
+    }
+  }
+  async setAssociations(value) {
+    var _a, _b;
+    const dataIndex = ((_b = (_a = this.ctx) == null ? void 0 : _a.column) == null ? void 0 : _b.dataIndex) || [];
+    if (Array.isArray(dataIndex) && dataIndex.length < 2) {
+      this.errors.push(`data index invalid`);
+      return;
+    }
+    const key = this.ctx.column.dataIndex[1];
+    const repository = this.field.database.getRepository(this.field.target);
+    try {
+      this.value = await Promise.all(
+        this.toArr(value).map(async (v) => {
+          const instance = await repository.findOne({ filter: { [key]: v } });
+          if (!instance) {
+            throw new Error(`"${v}" does not exist`);
+          }
+          return instance.get(this.field.targetKey || "id");
+        })
+      );
+    } catch (error) {
+      this.errors.push(error.message);
+    }
+  }
+  async setValue(value) {
+    const setAccessor = this.setAccessors[this.getInterface()] || "setAssociations";
+    await this[setAccessor](value);
+  }
+  getInterface() {
+    var _a, _b;
+    return (_b = (_a = this.field) == null ? void 0 : _a.options) == null ? void 0 : _b.interface;
+  }
+  isInterface(name) {
+    return this.getInterface() === name;
+  }
+};
+__name(_ToManyValueParser, "ToManyValueParser");
+let ToManyValueParser = _ToManyValueParser;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToManyValueParser
+});

package/lib/value-parsers/to-one-value-parser.d.ts

@@ -0,0 +1,4 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class ToOneValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/to-one-value-parser.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var to_one_value_parser_exports = {};
+__export(to_one_value_parser_exports, {
+  ToOneValueParser: () => ToOneValueParser
+});
+module.exports = __toCommonJS(to_one_value_parser_exports);
+var import_base_value_parser = require("./base-value-parser");
+const _ToOneValueParser = class _ToOneValueParser extends import_base_value_parser.BaseValueParser {
+  async setValue(value) {
+    var _a, _b;
+    const dataIndex = ((_b = (_a = this.ctx) == null ? void 0 : _a.column) == null ? void 0 : _b.dataIndex) || [];
+    if (Array.isArray(dataIndex) && dataIndex.length < 2) {
+      this.errors.push(`data index invalid`);
+      return;
+    }
+    const key = this.ctx.column.dataIndex[1];
+    const repository = this.field.database.getRepository(this.field.target);
+    const instance = await repository.findOne({ filter: { [key]: this.trim(value) } });
+    if (instance) {
+      this.value = instance.get(this.field.targetKey || "id");
+    } else {
+      this.errors.push(`"${value}" does not exist`);
+    }
+  }
+};
+__name(_ToOneValueParser, "ToOneValueParser");
+let ToOneValueParser = _ToOneValueParser;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToOneValueParser
+});

package/lib/view/field-type-map.d.ts

@@ -0,0 +1,97 @@
+declare const _default: {
+    postgres: {
+        'character varying': string[];
+        varchar: string[];
+        char: string[];
+        character: string;
+        text: string;
+        oid: string;
+        name: string;
+        smallint: string[];
+        integer: string[];
+        bigint: string[];
+        decimal: string;
+        numeric: string;
+        real: string;
+        'double precision': string;
+        'timestamp without time zone': string;
+        'timestamp with time zone': string;
+        'time without time zone': string;
+        date: string;
+        boolean: string;
+        json: string[];
+        jsonb: string[];
+        point: string;
+        path: string;
+        polygon: string;
+        circle: string;
+        uuid: string;
+    };
+    mysql: {
+        smallint: string[];
+        tinyint: string[];
+        mediumint: string[];
+        'smallint unsigned': string[];
+        'tinyint unsigned': string[];
+        'mediumint unsigned': string[];
+        char: string[];
+        varchar: string[];
+        date: string;
+        time: string;
+        text: string;
+        longtext: string;
+        int: string[];
+        'int unsigned': string[];
+        integer: string[];
+        bigint: string[];
+        'bigint unsigned': string[];
+        float: string;
+        double: string;
+        boolean: string;
+        decimal: string;
+        datetime: string;
+        timestamp: string;
+        json: string[];
+        enum: string;
+    };
+    sqlite: {
+        text: string;
+        varchar: string[];
+        integer: string;
+        real: string;
+        datetime: string;
+        date: string;
+        time: string;
+        boolean: string;
+        numeric: string;
+        json: string[];
+    };
+    mariadb: {
+        smallint: string[];
+        tinyint: string[];
+        mediumint: string[];
+        'smallint unsigned': string[];
+        'tinyint unsigned': string[];
+        'mediumint unsigned': string[];
+        char: string[];
+        varchar: string[];
+        date: string;
+        time: string;
+        text: string;
+        longtext: string;
+        int: string[];
+        'int unsigned': string[];
+        integer: string[];
+        bigint: string[];
+        'bigint unsigned': string[];
+        float: string;
+        double: string;
+        boolean: string;
+        decimal: string;
+        datetime: string;
+        timestamp: string;
+        json: string[];
+        enum: string;
+    };
+};
+export default _default;

package/lib/view/field-type-map.js

@@ -0,0 +1,90 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var field_type_map_exports = {};
+__export(field_type_map_exports, {
+  default: () => field_type_map_default
+});
+module.exports = __toCommonJS(field_type_map_exports);
+const postgres = {
+  "character varying": ["string", "uuid", "nanoid"],
+  varchar: ["string", "uuid", "nanoid"],
+  char: ["string", "uuid", "nanoid"],
+  character: "string",
+  text: "text",
+  oid: "string",
+  name: "string",
+  smallint: ["integer", "sort"],
+  integer: ["integer", "sort"],
+  bigint: ["bigInt", "sort"],
+  decimal: "decimal",
+  numeric: "float",
+  real: "float",
+  "double precision": "float",
+  "timestamp without time zone": "date",
+  "timestamp with time zone": "date",
+  "time without time zone": "time",
+  date: "date",
+  boolean: "boolean",
+  json: ["json", "array"],
+  jsonb: ["json", "array", "jsonb"],
+  point: "json",
+  path: "json",
+  polygon: "json",
+  circle: "json",
+  uuid: "uuid"
+};
+const mysql = {
+  smallint: ["integer", "boolean", "sort"],
+  tinyint: ["integer", "boolean", "sort"],
+  mediumint: ["integer", "boolean", "sort"],
+  "smallint unsigned": ["integer", "boolean", "sort"],
+  "tinyint unsigned": ["integer", "boolean", "sort"],
+  "mediumint unsigned": ["integer", "boolean", "sort"],
+  char: ["string", "uuid", "nanoid"],
+  varchar: ["string", "uuid", "nanoid"],
+  date: "date",
+  time: "time",
+  text: "text",
+  longtext: "text",
+  int: ["integer", "sort"],
+  "int unsigned": ["integer", "sort"],
+  integer: ["integer", "sort"],
+  bigint: ["bigInt", "sort"],
+  "bigint unsigned": ["bigInt", "sort"],
+  float: "float",
+  double: "float",
+  boolean: "boolean",
+  decimal: "decimal",
+  datetime: "date",
+  timestamp: "date",
+  json: ["json", "array"],
+  enum: "string"
+};
+const sqlite = {
+  text: "text",
+  varchar: ["string", "uuid", "nanoid"],
+  integer: "integer",
+  real: "real",
+  datetime: "date",
+  date: "date",
+  time: "time",
+  boolean: "boolean",
+  numeric: "decimal",
+  json: ["json", "array"]
+};
+var field_type_map_default = { postgres, mysql, sqlite, mariadb: mysql };

package/lib/view/view-inference.d.ts

@@ -0,0 +1,32 @@
+import Database from '../database';
+type InferredField = {
+    name: string;
+    type: string;
+    source?: string;
+};
+type InferredFieldResult = {
+    [key: string]: InferredField;
+};
+export declare class ViewFieldInference {
+    static extractTypeFromDefinition(typeDefinition: any): any;
+    static inferFields(options: {
+        db: Database;
+        viewName: string;
+        viewSchema?: string;
+    }): Promise<InferredFieldResult>;
+    static inferToFieldType(options: {
+        name: string;
+        type: string;
+        dialect: string;
+    }): {
+        possibleTypes: string[];
+        type?: undefined;
+    } | {
+        type: any;
+        possibleTypes: any[];
+    } | {
+        type: any;
+        possibleTypes?: undefined;
+    };
+}
+export {};

package/lib/view/view-inference.js

@@ -0,0 +1,146 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var view_inference_exports = {};
+__export(view_inference_exports, {
+  ViewFieldInference: () => ViewFieldInference
+});
+module.exports = __toCommonJS(view_inference_exports);
+var import_mathjs = require("mathjs");
+var import_field_type_map = __toESM(require("./field-type-map"));
+const _ViewFieldInference = class _ViewFieldInference {
+  static extractTypeFromDefinition(typeDefinition) {
+    const leftParenIndex = typeDefinition.indexOf("(");
+    if (leftParenIndex === -1) {
+      return typeDefinition.toLowerCase();
+    }
+    return typeDefinition.substring(0, leftParenIndex).toLowerCase().trim();
+  }
+  static async inferFields(options) {
+    const { db } = options;
+    if (!db.inDialect("postgres")) {
+      options.viewSchema = void 0;
+    }
+    const columns = await db.sequelize.getQueryInterface().describeTable(options.viewName, options.viewSchema);
+    const columnUsage = await db.queryInterface.viewColumnUsage({
+      viewName: options.viewName,
+      schema: options.viewSchema
+    });
+    const rawFields = [];
+    for (const [name, column] of Object.entries(columns)) {
+      const inferResult = { name };
+      const usage = columnUsage[name];
+      if (usage) {
+        const collection = db.tableNameCollectionMap.get(
+          `${usage.table_schema ? `${usage.table_schema}.` : ""}${usage.table_name}`
+        );
+        const collectionField = (() => {
+          if (!collection) return false;
+          const fieldAttribute = Object.values(collection.model.rawAttributes).find(
+            (field) => field.field === usage.column_name
+          );
+          if (!fieldAttribute) {
+            return false;
+          }
+          const fieldName = fieldAttribute.fieldName;
+          return collection.getField(fieldName);
+        })();
+        const belongsToAssociationField = (() => {
+          if (!collection) return false;
+          const field = Object.values(collection.model.rawAttributes).find(
+            (field2) => field2.field === usage.column_name
+          );
+          if (!field) {
+            return false;
+          }
+          const association = Object.values(collection.model.associations).find(
+            (association2) => association2.associationType === "BelongsTo" && association2.foreignKey === field.fieldName
+          );
+          if (!association) {
+            return false;
+          }
+          return collection.getField(association.as);
+        })();
+        if (belongsToAssociationField) {
+          rawFields.push([
+            belongsToAssociationField.name,
+            {
+              name: belongsToAssociationField.name,
+              type: belongsToAssociationField.type,
+              source: `${belongsToAssociationField.collection.name}.${belongsToAssociationField.name}`
+            }
+          ]);
+        }
+        if (collectionField) {
+          if (collectionField.options.interface) {
+            inferResult.type = collectionField.type;
+            inferResult.source = `${collectionField.collection.name}.${collectionField.name}`;
+          }
+        }
+      }
+      if (!inferResult.type) {
+        Object.assign(
+          inferResult,
+          this.inferToFieldType({
+            dialect: db.sequelize.getDialect(),
+            name,
+            type: column.type
+          })
+        );
+      }
+      rawFields.push([name, inferResult]);
+    }
+    return Object.fromEntries(rawFields);
+  }
+  static inferToFieldType(options) {
+    const { dialect } = options;
+    const fieldTypeMap = import_field_type_map.default[dialect];
+    if (!options.type) {
+      return {
+        possibleTypes: Object.keys(fieldTypeMap)
+      };
+    }
+    const queryType = this.extractTypeFromDefinition(options.type);
+    const mappedType = fieldTypeMap[queryType];
+    if ((0, import_mathjs.isArray)(mappedType)) {
+      return {
+        type: mappedType[0],
+        possibleTypes: mappedType
+      };
+    }
+    return {
+      type: mappedType
+    };
+  }
+};
+__name(_ViewFieldInference, "ViewFieldInference");
+let ViewFieldInference = _ViewFieldInference;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ViewFieldInference
+});

package/lib/view-collection.d.ts

@@ -0,0 +1,6 @@
+import { Collection, CollectionContext, CollectionOptions } from './collection';
+export declare class ViewCollection extends Collection {
+    constructor(options: CollectionOptions, context: CollectionContext);
+    isView(): boolean;
+    protected sequelizeModelOptions(): any;
+}

package/lib/view-collection.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var view_collection_exports = {};
+__export(view_collection_exports, {
+  ViewCollection: () => ViewCollection
+});
+module.exports = __toCommonJS(view_collection_exports);
+var import_collection = require("./collection");
+const _ViewCollection = class _ViewCollection extends import_collection.Collection {
+  constructor(options, context) {
+    options.autoGenId = false;
+    options.timestamps = false;
+    super(options, context);
+  }
+  isView() {
+    return true;
+  }
+  sequelizeModelOptions() {
+    const modelOptions = super.sequelizeModelOptions();
+    modelOptions.tableName = this.options.viewName || this.options.name;
+    return modelOptions;
+  }
+};
+__name(_ViewCollection, "ViewCollection");
+let ViewCollection = _ViewCollection;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ViewCollection
+});