@nocobase/database 0.9.4-alpha.1 → 0.10.0-alpha.2

package/src/repository.ts

@@ -32,6 +32,7 @@ import { RelationRepository } from './relation-repository/relation-repository';
 import { updateAssociations, updateModelByValues } from './update-associations';
 import { UpdateGuard } from './update-guard';
 import { EagerLoadingTree } from './eager-loading/eager-loading-tree';
+import { flatten } from 'flat';
 
 const debug = require('debug')('noco-database');
 
@@ -210,6 +211,11 @@ export interface AggregateOptions {
   distinct?: boolean;
 }
 
+interface FirstOrCreateOptions extends Transactionable {
+  filterKeys: string[];
+  values?: Values;
+}
+
 export class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes>
   implements IRepository
 {
@@ -223,6 +229,50 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     this.model = collection.model;
   }
 
+  public static valuesToFilter(values: Values, filterKeys: Array<string>) {
+    const filterAnd = [];
+    const flattedValues = flatten(values);
+
+    const keyWithOutArrayIndex = (key) => {
+      const chunks = key.split('.');
+      return chunks
+        .filter((chunk) => {
+          return !Boolean(chunk.match(/\d+/));
+        })
+        .join('.');
+    };
+
+    for (const filterKey of filterKeys) {
+      let filterValue;
+
+      for (const flattedKey of Object.keys(flattedValues)) {
+        const flattedKeyWithoutIndex = keyWithOutArrayIndex(flattedKey);
+
+        if (flattedKeyWithoutIndex === filterKey) {
+          if (filterValue) {
+            if (Array.isArray(filterValue)) {
+              filterValue.push(flattedValues[flattedKey]);
+            } else {
+              filterValue = [filterValue, flattedValues[flattedKey]];
+            }
+          } else {
+            filterValue = flattedValues[flattedKey];
+          }
+        }
+      }
+
+      if (filterValue) {
+        filterAnd.push({
+          [filterKey]: filterValue,
+        });
+      }
+    }
+
+    return {
+      $and: filterAnd,
+    };
+  }
+
   /**
    * return count by filter
    */
@@ -367,6 +417,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
         rootAttributes: opts.attributes,
         includeOption: opts.include,
         rootOrder: opts.order,
+        db: this.database,
       });
 
       await eagerLoadingTree.load(
@@ -427,6 +478,39 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     return rows.length == 1 ? rows[0] : null;
   }
 
+  /**
+   * Get the first record matching the attributes or create it.
+   */
+  async firstOrCreate(options: FirstOrCreateOptions) {
+    const { filterKeys, values, transaction } = options;
+    const filter = Repository.valuesToFilter(values, filterKeys);
+
+    const instance = await this.findOne({ filter, transaction });
+
+    if (instance) {
+      return instance;
+    }
+
+    return this.create({ values, transaction });
+  }
+
+  async updateOrCreate(options: FirstOrCreateOptions) {
+    const { filterKeys, values, transaction } = options;
+    const filter = Repository.valuesToFilter(values, filterKeys);
+
+    const instance = await this.findOne({ filter, transaction });
+
+    if (instance) {
+      return await this.update({
+        filterByTk: instance.get(this.collection.model.primaryKeyAttribute),
+        values,
+        transaction,
+      });
+    }
+
+    return this.create({ values, transaction });
+  }
+
   /**
    * Save instance to database
    *

package/src/update-associations.ts

@@ -200,6 +200,7 @@ function isReverseAssociationPair(a: any, b: any) {
 
     return (
       sourceAssoc.source.name === targetAssoc.target.name &&
+      sourceAssoc.target.name === targetAssoc.source.name &&
       sourceAssoc.foreignKey === targetAssoc.foreignKey &&
       sourceAssoc.sourceKey === targetAssoc.targetKey
     );
@@ -339,12 +340,14 @@ export async function updateSingleAssociation(
     }
 
     const instance = await model[createAccessor](value, { context, transaction });
+
     await updateAssociations(instance, value, {
       ...options,
       transaction,
       associationContext: association,
       updateAssociationValues: keys,
     });
+
     model.setDataValue(key, instance);
     // @ts-ignore
     if (association.targetKey) {

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

@@ -3,6 +3,8 @@ const postgres = {
   varchar: 'string',
   text: 'text',
   char: 'string',
+  oid: 'string',
+  name: 'string',
 
   smallint: 'integer',
   integer: 'integer',

package/src/view/view-inference.ts

@@ -30,52 +30,84 @@ export class ViewFieldInference {
       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}`,
-              },
-            ];
+    const rawFields = [];
+    for (const [name, column] of Object.entries(columns)) {
+      const inferResult: any = { 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;
+          }
+
+          // @ts-ignore
+          const fieldName = fieldAttribute.fieldName;
+
+          return collection.getField(fieldName);
+        })();
+
+        const belongsToAssociationField = (() => {
+          if (!collection) return false;
+
+          const field = Object.values(collection.model.rawAttributes).find(
+            (field) => field.field === usage.column_name,
+          );
+
+          if (!field) {
+            return false;
+          }
+
+          const association = Object.values(collection.model.associations).find(
+            (association) =>
+              association.associationType === 'BelongsTo' && association.foreignKey === (field as any).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({ db, name, type: column.type }));
+      }
+
+      rawFields.push([name, inferResult]);
+    }
 
-        return [
-          name,
-          {
-            name,
-            ...this.inferToFieldType({ db, name, type: column.type }),
-          },
-        ];
-      }),
-    );
+    return Object.fromEntries(rawFields);
   }
 
   static inferToFieldType(options: { db: Database; name: string; type: string }) {

package/src/view-collection.ts

@@ -4,7 +4,6 @@ export class ViewCollection extends Collection {
   constructor(options: CollectionOptions, context: CollectionContext) {
     options.autoGenId = false;
     options.timestamps = false;
-    options.underscored = false;
 
     super(options, context);
   }