@nocobase/database 0.9.1-alpha.2 → 0.9.2-alpha.2

package/src/sync-runner.ts

@@ -26,7 +26,7 @@ export class SyncRunner {
       );
     }
 
-    const tableName = inheritedCollection.addSchemaTableName();
+    const tableName = inheritedCollection.getTableNameWithSchema();
 
     const attributes = model.tableAttributes;
 
@@ -44,7 +44,7 @@ export class SyncRunner {
           `SELECT column_default
            FROM information_schema.columns
            WHERE table_name = '${parent.model.tableName}'
-            and table_schema = '${parent.collectionSchema()}'
+             and table_schema = '${parent.collectionSchema()}'
              and "column_name" = 'id';`,
           {
             transaction,
@@ -65,7 +65,6 @@ export class SyncRunner {
         const match = regex.exec(columnDefault);
 
         const sequenceName = match[1];
-
         const sequenceCurrentValResult = await queryInterface.sequelize.query(
           `select last_value
            from ${sequenceName}`,
@@ -88,7 +87,7 @@ export class SyncRunner {
     // if we have max sequence, set it to child table
     if (maxSequenceName) {
       const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map((parent) =>
-        db.getCollection(parent).addSchemaTableName(),
+        db.getCollection(parent).getTableNameWithSchema(),
       );
 
       const sequenceTables = [...parentsDeep, tableName];
@@ -97,17 +96,16 @@ export class SyncRunner {
         const tableName = sequenceTable.tableName;
         const schemaName = sequenceTable.schema;
 
-        const queryName = Boolean(tableName.match(/[A-Z]/)) && !tableName.includes(`"`) ? `"${tableName}"` : tableName;
+        const idColumnSql = `SELECT column_name
+           FROM information_schema.columns
+           WHERE table_name = '${tableName}'
+             and column_name = 'id'
+             and table_schema = '${schemaName}';
+          `;
 
-        const idColumnQuery = await queryInterface.sequelize.query(
-          `SELECT column_name
-FROM information_schema.columns
-WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schemaName}';
-          `,
-          {
-            transaction,
-          },
-        );
+        const idColumnQuery = await queryInterface.sequelize.query(idColumnSql, {
+          transaction,
+        });
 
         if (idColumnQuery[0].length == 0) {
           continue;
@@ -163,7 +161,7 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
       ';',
       ` INHERITS (${parents
         .map((t) => {
-          return t.addSchemaTableName();
+          return t.getTableNameWithSchema();
         })
         .join(', ')});`,
     );

package/src/update-associations.ts

@@ -6,10 +6,11 @@ import {
   HasOne,
   Hookable,
   ModelStatic,
-  Transactionable
+  Transactionable,
 } from 'sequelize';
 import { Model } from './model';
 import { UpdateGuard } from './update-guard';
+import lodash from 'lodash';
 
 function isUndefinedOrNull(value: any) {
   return typeof value === 'undefined' || value === null;
@@ -396,38 +397,40 @@ export async function updateMultipleAssociation(
       return;
     }
 
-    if (!Array.isArray(value)) {
-      value = [value];
-    }
+    value = lodash.castArray(value);
+
+    const setItems = []; // to be setted
+    const objectItems = []; // to be added
 
-    const list1 = []; // to be setted
-    const list2 = []; // to be added
-    const created = [];
+    // iterate item in value
     for (const item of value) {
       if (isUndefinedOrNull(item)) {
         continue;
       }
+
       if (isStringOrNumber(item)) {
-        list1.push(item);
+        setItems.push(item);
       } else if (item instanceof Model) {
-        list1.push(item);
+        setItems.push(item);
       } else if (item.sequelize) {
-        list1.push(item);
+        setItems.push(item);
       } else if (typeof item === 'object') {
         const targetKey = (association as any).targetKey || 'id';
+
         if (item[targetKey]) {
-          created.push(item[targetKey]);
-          list1.push(item[targetKey]);
+          setItems.push(item[targetKey]);
         }
-        list2.push(item);
+
+        objectItems.push(item);
       }
     }
 
     // associate targets in lists1
-    await model[setAccessor](list1, { transaction, context, individualHooks: true });
+    await model[setAccessor](setItems, { transaction, context, individualHooks: true });
 
-    const list3 = [];
-    for (const item of list2) {
+    const newItems = [];
+
+    for (const item of objectItems) {
       const pk = association.target.primaryKeyAttribute;
 
       const through = (<any>association).through ? (<any>association).through.model.name : null;
@@ -446,13 +449,14 @@ export async function updateMultipleAssociation(
       if (isUndefinedOrNull(item[pk])) {
         // create new record
         const instance = await model[createAccessor](item, accessorOptions);
+
         await updateAssociations(instance, item, {
           ...options,
           transaction,
           associationContext: association,
           updateAssociationValues: keys,
         });
-        list3.push(instance);
+        newItems.push(instance);
       } else {
         // set & update record
         const instance = await association.target.findByPk<any>(item[pk], {
@@ -462,9 +466,9 @@ export async function updateMultipleAssociation(
           continue;
         }
         const addAccessor = association.accessors.add;
-        if (!created.includes(item[pk])) {
-          await model[addAccessor](item[pk], accessorOptions);
-        }
+
+        await model[addAccessor](item[pk], accessorOptions);
+
         if (!recursive) {
           continue;
         }
@@ -477,11 +481,11 @@ export async function updateMultipleAssociation(
           associationContext: association,
           updateAssociationValues: keys,
         });
-        list3.push(instance);
+        newItems.push(instance);
       }
     }
 
-    model.setDataValue(key, list1.concat(list3));
+    model.setDataValue(key, setItems.concat(newItems));
   } catch (error) {
     throw error;
   }

package/src/view/field-type-map.ts

@@ -0,0 +1,56 @@
+const postgres = {
+  'character varying': 'string',
+  varchar: 'string',
+  text: 'text',
+  char: 'string',
+
+  smallint: 'integer',
+  integer: 'integer',
+  bigint: 'bigInt',
+  decimal: 'float',
+  numeric: 'float',
+  'double precision': 'float',
+
+  'timestamp without time zone': 'date',
+  'timestamp with time zone': 'date',
+  date: 'date',
+  boolean: 'boolean',
+
+  json: ['json', 'array'],
+  jsonb: ['jsonb', 'array'],
+};
+
+const mysql = {
+  varchar: 'string',
+  text: 'text',
+  int: 'integer',
+  integer: 'integer',
+  bigint: 'bigInt',
+  float: 'float',
+  double: 'float',
+  boolean: 'boolean',
+
+  tinyint: 'integer',
+  datetime: 'date',
+  timestamp: 'date',
+  json: ['json', 'array'],
+};
+
+const sqlite = {
+  text: 'text',
+  varchar: 'string',
+
+  integer: 'integer',
+  real: 'real',
+
+  datetime: 'date',
+  date: 'date',
+  time: 'time',
+
+  boolean: 'boolean',
+
+  numeric: 'decimal',
+  json: ['json', 'array'],
+};
+
+export default { postgres, mysql, sqlite };

package/src/view/view-inference.ts

@@ -0,0 +1,106 @@
+import Database from '../database';
+import FieldTypeMap from './field-type-map';
+import { isArray } from 'mathjs';
+
+type InferredField = {
+  name: string;
+  type: string;
+  source?: string;
+};
+
+type InferredFieldResult = {
+  [key: string]: InferredField;
+};
+
+export class ViewFieldInference {
+  static async inferFields(options: {
+    db: Database;
+    viewName: string;
+    viewSchema?: string;
+  }): Promise<InferredFieldResult> {
+    const { db } = options;
+    if (!db.inDialect('postgres')) {
+      options.viewSchema = undefined;
+    }
+
+    const columns = await db.sequelize.getQueryInterface().describeTable(options.viewName, options.viewSchema);
+
+    const columnUsage = await db.queryInterface.viewColumnUsage({
+      viewName: options.viewName,
+      schema: options.viewSchema,
+    });
+
+    // @ts-ignore
+    return Object.fromEntries(
+      Object.entries(columns).map(([name, column]) => {
+        const usage = columnUsage[name];
+
+        if (usage) {
+          const collectionField = (() => {
+            const tableName = `${usage.table_schema ? `${usage.table_schema}.` : ''}${usage.table_name}`;
+            const collection = db.tableNameCollectionMap.get(tableName);
+            if (!collection) return false;
+
+            const fieldValue = Object.values(collection.model.rawAttributes).find(
+              (field) => field.field === usage.column_name,
+            );
+
+            if (!fieldValue) {
+              return false;
+            }
+
+            // @ts-ignore
+            const fieldName = fieldValue?.fieldName;
+
+            return collection.getField(fieldName);
+          })();
+
+          if (collectionField && collectionField.options.interface) {
+            return [
+              name,
+              {
+                name,
+                type: collectionField.type,
+                source: `${collectionField.collection.name}.${collectionField.name}`,
+              },
+            ];
+          }
+        }
+
+        return [
+          name,
+          {
+            name,
+            ...this.inferToFieldType({ db, name, type: column.type }),
+          },
+        ];
+      }),
+    );
+  }
+
+  static inferToFieldType(options: { db: Database; name: string; type: string }) {
+    const { db } = options;
+    const dialect = db.sequelize.getDialect();
+    const fieldTypeMap = FieldTypeMap[dialect];
+
+    if (!options.type) {
+      return {
+        possibleTypes: Object.keys(fieldTypeMap),
+      };
+    }
+
+    const queryType = options.type.toLowerCase().replace(/\(\d+\)/, '');
+    const mappedType = fieldTypeMap[queryType];
+
+    if (isArray(mappedType)) {
+      return {
+        type: mappedType[0],
+        possibleTypes: mappedType,
+      };
+    }
+
+    return {
+      type: mappedType,
+    };
+  }
+}

package/src/view-collection.ts

@@ -0,0 +1,21 @@
+import { Collection, CollectionContext, CollectionOptions } from './collection';
+
+export class ViewCollection extends Collection {
+  constructor(options: CollectionOptions, context: CollectionContext) {
+    options.autoGenId = false;
+    options.timestamps = false;
+    options.underscored = false;
+
+    super(options, context);
+  }
+
+  protected sequelizeModelOptions(): any {
+    const modelOptions = super.sequelizeModelOptions();
+    modelOptions.tableName = this.options.viewName || this.options.name;
+    return modelOptions;
+  }
+
+  isView() {
+    return true;
+  }
+}