@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.10

package/src/operators/array.ts

@@ -0,0 +1,145 @@
+import { Op, Sequelize } from 'sequelize';
+import { isPg, isMySQL } from './utils';
+
+const getFieldName = (ctx) => {
+  const fieldName = ctx.fieldName;
+  return fieldName;
+};
+
+const escape = (value, ctx) => {
+  const sequelize: Sequelize = ctx.db.sequelize;
+  return sequelize.escape(value);
+};
+
+const sqliteExistQuery = (value, ctx) => {
+  const fieldName = getFieldName(ctx);
+
+  const sqlArray = `(${value.map((v) => `'${v}'`).join(', ')})`;
+
+  const subQuery = `exists (select * from json_each(${fieldName}) where json_each.value in ${sqlArray})`;
+
+  return subQuery;
+};
+
+const emptyQuery = (ctx, operator: '=' | '>') => {
+  const fieldName = getFieldName(ctx);
+
+  let funcName = 'json_array_length';
+  let ifNull = 'IFNULL';
+
+  if (isPg(ctx)) {
+    funcName = 'jsonb_array_length';
+    ifNull = 'coalesce';
+  }
+
+  if (isMySQL(ctx)) {
+    funcName = 'json_length';
+  }
+
+  return `(select ${ifNull}(${funcName}(${fieldName}), 0) ${operator} 0)`;
+};
+
+export default {
+  $match(value, ctx) {
+    const fieldName = getFieldName(ctx);
+
+    if (isPg(ctx)) {
+      return {
+        [Op.contained]: value,
+        [Op.contains]: value,
+      };
+    }
+
+    value = escape(JSON.stringify(value.sort()), ctx);
+
+    if (isMySQL(ctx)) {
+      return Sequelize.literal(`JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName})`);
+    }
+
+    return {
+      [Op.eq]: Sequelize.literal(`json(${value})`),
+    };
+  },
+
+  $notMatch(value, ctx) {
+    const fieldName = getFieldName(ctx);
+    value = escape(JSON.stringify(value), ctx);
+
+    if (isPg(ctx)) {
+      return Sequelize.literal(`not (${fieldName} <@ ${value}::JSONB and ${fieldName} @> ${value}::JSONB)`);
+    }
+
+    if (isMySQL(ctx)) {
+      return Sequelize.literal(`not (JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName}))`);
+    }
+    return {
+      [Op.ne]: Sequelize.literal(`json(${value})`),
+    };
+  },
+
+  $anyOf(value, ctx) {
+    const fieldName = getFieldName(ctx);
+
+    if (isPg(ctx)) {
+      return Sequelize.literal(
+        `${fieldName} ?| ${escape(
+          value.map((i) => `${i}`),
+          ctx,
+        )}`,
+      );
+    }
+
+    if (isMySQL(ctx)) {
+      value = escape(JSON.stringify(value), ctx);
+
+      return Sequelize.literal(`JSON_OVERLAPS(${fieldName}, ${value})`);
+    }
+
+    const subQuery = sqliteExistQuery(value, ctx);
+
+    return Sequelize.literal(subQuery);
+  },
+
+  $noneOf(value, ctx) {
+    let where;
+
+    if (isPg(ctx)) {
+      const fieldName = getFieldName(ctx);
+      // pg single quote
+      where = Sequelize.literal(
+        `not (${fieldName} ?| ${escape(
+          value.map((i) => `${i}`),
+          ctx,
+        )})`,
+      );
+    } else if (isMySQL(ctx)) {
+      const fieldName = getFieldName(ctx);
+      value = escape(JSON.stringify(value), ctx);
+      where = Sequelize.literal(`NOT JSON_OVERLAPS(${fieldName}, ${value})`);
+    } else {
+      const subQuery = sqliteExistQuery(value, ctx);
+
+      where = Sequelize.literal(`not ${subQuery}`);
+    }
+
+    return {
+      [Op.or]: [where, { [Op.is]: null }],
+    };
+  },
+
+  $arrayEmpty(value, ctx) {
+    const subQuery = emptyQuery(ctx, '=');
+
+    return {
+      [Op.and]: [Sequelize.literal(`${subQuery}`)],
+    };
+  },
+
+  $arrayNotEmpty(value, ctx) {
+    const subQuery = emptyQuery(ctx, '>');
+
+    return {
+      [Op.and]: [Sequelize.literal(`${subQuery}`)],
+    };
+  },
+};

package/src/operators/association.ts

@@ -0,0 +1,14 @@
+import { Op, Sequelize } from 'sequelize';
+
+export default {
+  $exists(value, ctx) {
+    return {
+      [Op.not]: null,
+    };
+  },
+  $notExists(value, ctx) {
+    return {
+      [Op.is]: null,
+    };
+  },
+};

package/src/operators/date.ts

@@ -0,0 +1,41 @@
+import { Op } from 'sequelize';
+import moment, { MomentInput } from 'moment';
+function stringToDate(value: string): Date {
+  return moment(value).toDate();
+}
+
+function getNextDay(value: MomentInput): Date {
+  return moment(value).add(1, 'd').toDate();
+}
+
+export default {
+  $dateOn(value) {
+    return {
+      [Op.and]: [{ [Op.gte]: stringToDate(value) }, { [Op.lt]: getNextDay(value) }],
+    };
+  },
+
+  $dateNotOn(value) {
+    return {
+      [Op.or]: [{ [Op.lt]: stringToDate(value) }, { [Op.gte]: getNextDay(value) }],
+    };
+  },
+
+  $dateBefore(value) {
+    return { [Op.lt]: stringToDate(value) };
+  },
+
+  $dateNotBefore(value) {
+    return {
+      [Op.gte]: stringToDate(value),
+    };
+  },
+
+  $dateAfter(value) {
+    return { [Op.gte]: getNextDay(value) };
+  },
+
+  $dateNotAfter(value) {
+    return { [Op.lt]: getNextDay(value) };
+  },
+};

package/src/operators/empty.ts

@@ -0,0 +1,75 @@
+import { DataTypes, Op } from 'sequelize';
+import { ArrayField, StringField } from '../fields';
+import arrayOperators from './array';
+import lodash, { parseInt } from 'lodash';
+
+const findFilterFieldType = (ctx) => {
+  const db = ctx.db;
+
+  let path = ctx.path.split('.');
+
+  // remove operators
+  path.pop();
+
+  const fieldName = path.pop();
+
+  let model = ctx.model;
+
+  const associationPath = path;
+
+  for (const association of associationPath) {
+    if (lodash.isNumber(parseInt(association)) || association.startsWith('$')) {
+      continue;
+    }
+
+    model = model.associations[association].target;
+  }
+
+  const collection = db.modelCollection.get(model);
+
+  return collection.getField(fieldName);
+};
+
+export default {
+  $empty(_, ctx) {
+    const field = findFilterFieldType(ctx);
+
+    if (field instanceof StringField) {
+      return {
+        [Op.or]: {
+          [Op.is]: null,
+          [Op.eq]: '',
+        },
+      };
+    }
+
+    if (field instanceof ArrayField) {
+      return arrayOperators.$arrayEmpty(_, ctx);
+    }
+
+    return {
+      [Op.is]: null,
+    };
+  },
+
+  $notEmpty(_, ctx) {
+    const field = findFilterFieldType(ctx);
+
+    if (field instanceof StringField) {
+      return {
+        [Op.and]: {
+          [Op.not]: null,
+          [Op.ne]: '',
+        },
+      };
+    }
+
+    if (field instanceof ArrayField) {
+      return arrayOperators.$arrayNotEmpty(_, ctx);
+    }
+
+    return {
+      [Op.not]: null,
+    };
+  },
+};

package/src/operators/index.ts

@@ -0,0 +1,8 @@
+export default {
+  ...require('./association').default,
+  ...require('./date').default,
+  ...require('./array').default,
+  ...require('./empty').default,
+  ...require('./string').default,
+  ...require('./ne').default,
+};

package/src/operators/ne.ts

@@ -0,0 +1,12 @@
+import { Op } from 'sequelize';
+
+export default {
+  $ne(val, ctx) {
+    return {
+      [Op.or]: {
+        [Op.ne]: val,
+        [Op.is]: null,
+      },
+    };
+  },
+};

package/src/operators/string.ts

@@ -0,0 +1,40 @@
+import { isPg } from './utils';
+import { Op } from 'sequelize';
+
+export default {
+  $includes(value, ctx) {
+    return {
+      [isPg(ctx) ? Op.iLike : Op.like]: `%${value}%`,
+    };
+  },
+
+  $notIncludes(value, ctx) {
+    return {
+      [isPg(ctx) ? Op.notILike : Op.notLike]: `%${value}%`,
+    };
+  },
+
+  $startsWith(value, ctx) {
+    return {
+      [isPg(ctx) ? Op.iLike : Op.like]: `${value}%`,
+    };
+  },
+
+  $notStartsWith(value, ctx) {
+    return {
+      [isPg(ctx) ? Op.notILike : Op.notLike]: `${value}%`,
+    };
+  },
+
+  $endWith(value, ctx) {
+    return {
+      [isPg(ctx) ? Op.iLike : Op.like]: `%${value}`,
+    };
+  },
+
+  $notEndWith(value, ctx) {
+    return {
+      [isPg(ctx) ? Op.notILike : Op.notLike]: `%${value}`,
+    };
+  },
+};

package/src/operators/utils.ts

@@ -0,0 +1,13 @@
+const getDialect = (ctx) => {
+  return ctx.db.sequelize.getDialect();
+};
+
+const isPg = (ctx) => {
+  return getDialect(ctx) === 'postgres';
+};
+
+const isMySQL = (ctx) => {
+  return getDialect(ctx) === 'mysql';
+};
+
+export { getDialect, isPg, isMySQL };

package/src/options-parser.ts

@@ -0,0 +1,285 @@
+import { FindAttributeOptions, ModelCtor, Op } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+import FilterParser from './filter-parser';
+import { Appends, Except, FindOptions } from './repository';
+
+const debug = require('debug')('noco-database');
+
+interface OptionsParserContext {
+  collection: Collection;
+  targetKey?: string;
+}
+
+export class OptionsParser {
+  options: FindOptions;
+  database: Database;
+  collection: Collection;
+  model: ModelCtor<any>;
+  filterParser: FilterParser;
+  context: OptionsParserContext;
+
+  constructor(options: FindOptions, context: OptionsParserContext) {
+    const { collection } = context;
+
+    this.collection = collection;
+    this.model = collection.model;
+    this.options = options;
+    this.database = collection.context.database;
+    this.filterParser = new FilterParser(options?.filter, {
+      collection,
+      app: {
+        ctx: options?.context,
+      },
+    });
+    this.context = context;
+  }
+
+  isAssociation(key: string) {
+    return this.model.associations[key] !== undefined;
+  }
+
+  isAssociationPath(path: string) {
+    return this.isAssociation(path.split('.')[0]);
+  }
+
+  toSequelizeParams() {
+    const queryParams = this.filterParser.toSequelizeParams();
+
+    if (this.options?.filterByTk) {
+      queryParams.where = {
+        [Op.and]: [
+          queryParams.where,
+          {
+            [this.context.targetKey || this.collection.filterTargetKey]: this.options.filterByTk,
+          },
+        ],
+      };
+    }
+
+    return this.parseSort(this.parseFields(queryParams));
+  }
+
+  /**
+   * parser sort options
+   * @param filterParams
+   * @protected
+   */
+  protected parseSort(filterParams) {
+    let sort = this.options?.sort || [];
+    if (typeof sort === 'string') {
+      sort = sort.split(',');
+    }
+    const orderParams = sort.map((sortKey: string) => {
+      const direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
+      const sortField: Array<any> = sortKey.replace('-', '').split('.');
+
+      // handle sort by association
+      if (sortField.length > 1) {
+        let associationModel = this.model;
+
+        for (let i = 0; i < sortField.length - 1; i++) {
+          const associationKey = sortField[i];
+          sortField[i] = associationModel.associations[associationKey].target;
+          associationModel = sortField[i];
+        }
+      }
+
+      sortField.push(direction);
+      return sortField;
+    });
+
+    if (orderParams.length > 0) {
+      return {
+        order: orderParams,
+        ...filterParams,
+      };
+    }
+
+    return filterParams;
+  }
+
+  protected parseFields(filterParams: any) {
+    const appends = this.options?.appends || [];
+    const except = [];
+
+    let attributes: FindAttributeOptions = {
+      include: [],
+      exclude: [],
+    }; // out put all fields by default
+
+    if (this.options?.fields) {
+      // 将fields拆分为 attributes 和 appends
+      for (const field of this.options.fields) {
+        if (this.isAssociationPath(field)) {
+          // field is association field
+          appends.push(field);
+        } else {
+          // field is model attribute, change attributes to array type
+          if (!Array.isArray(attributes)) attributes = [];
+
+          attributes.push(field);
+        }
+      }
+    }
+
+    if (this.options?.except) {
+      for (const exceptKey of this.options.except) {
+        if (this.isAssociationPath(exceptKey)) {
+          // except association field
+          except.push(exceptKey);
+        } else {
+          // if attributes is array form, ignore except
+          if (Array.isArray(attributes)) continue;
+          attributes.exclude.push(exceptKey);
+        }
+      }
+    }
+
+    return {
+      attributes,
+      ...this.parseExcept(except, this.parseAppends(appends, filterParams)),
+    };
+  }
+
+  protected parseExcept(except: Except, filterParams: any) {
+    if (!except) return filterParams;
+    const setExcept = (queryParams: any, except: string) => {
+      // split exceptKey to path form
+      // posts.comments.content => ['posts', 'comments', 'content']
+      // then set except on include attributes
+      const exceptPath = except.split('.');
+      const association = exceptPath[0];
+      const lastLevel = exceptPath.length <= 2;
+
+      let existIncludeIndex = queryParams['include'].findIndex((include) => include['association'] == association);
+
+      if (existIncludeIndex == -1) {
+        // if include not exists, ignore this except
+        return;
+      }
+
+      if (lastLevel) {
+        // if it not have exclude form
+        if (Array.isArray(queryParams['include'][existIncludeIndex]['attributes'])) {
+          return;
+        } else {
+          if (!queryParams['include'][existIncludeIndex]['attributes']['exclude']) {
+            queryParams['include'][existIncludeIndex]['attributes']['exclude'] = [];
+          }
+
+          queryParams['include'][existIncludeIndex]['attributes']['exclude'].push(exceptPath[1]);
+        }
+      } else {
+        setExcept(queryParams['include'][existIncludeIndex], exceptPath.filter((_, index) => index !== 0).join('.'));
+      }
+    };
+
+    for (const exceptKey of except) {
+      setExcept(filterParams, exceptKey);
+    }
+
+    return filterParams;
+  }
+
+  protected parseAppends(appends: Appends, filterParams: any) {
+    if (!appends) return filterParams;
+
+    /**
+     * set include params
+     * @param includeRoot
+     * @param appends
+     */
+    const setInclude = (model: ModelCtor<any>, queryParams: any, append: string) => {
+      const appendFields = append.split('.');
+      const appendAssociation = appendFields[0];
+
+      const associations = model.associations;
+
+      // if append length less or equal 2
+      // example:
+      //  appends: ['posts']
+      //  appends: ['posts.title']
+      //  All of these can be seen as last level
+      let lastLevel: boolean = false;
+
+      if (appendFields.length == 1) {
+        lastLevel = true;
+      }
+
+      if (appendFields.length == 2) {
+        const associationModel = associations[appendFields[0]].target;
+        if (associationModel.rawAttributes[appendFields[1]]) {
+          lastLevel = true;
+        }
+      }
+
+      // find association index
+      if (queryParams['include'] == undefined) {
+        queryParams['include'] = [];
+      }
+
+      let existIncludeIndex = queryParams['include'].findIndex(
+        (include) => include['association'] == appendAssociation,
+      );
+
+      // if association not exist, create it
+      if (existIncludeIndex == -1) {
+        // association not exists
+        queryParams['include'].push({
+          association: appendAssociation,
+        });
+
+        existIncludeIndex = 0;
+      }
+
+      // end appends
+      // without nests association
+      if (lastLevel) {
+        // get exist association attributes
+        let attributes = queryParams['include'][existIncludeIndex]['attributes'] || {
+          include: [], // all fields are output by default
+        };
+
+        // if need set attribute
+        if (appendFields.length == 2) {
+          if (!Array.isArray(attributes)) {
+            attributes = [];
+          }
+
+          const attributeName = appendFields[1];
+
+          // push field to it
+          attributes.push(attributeName);
+        } else {
+          // if attributes is empty array, change it to object
+          if (Array.isArray(attributes) && attributes.length == 0) {
+            attributes = {
+              include: [],
+            };
+          }
+        }
+
+        // set new attributes
+        queryParams['include'][existIncludeIndex] = {
+          ...queryParams['include'][existIncludeIndex],
+          attributes,
+        };
+      } else {
+        setInclude(
+          model.associations[queryParams['include'][existIncludeIndex].association].target,
+          queryParams['include'][existIncludeIndex],
+          appendFields.filter((_, index) => index !== 0).join('.'),
+        );
+      }
+    };
+
+    // handle every appends
+    for (const append of appends) {
+      setInclude(this.model, filterParams, append);
+    }
+
+    debug('filter params: %o', filterParams);
+    return filterParams;
+  }
+}

package/src/playground.ts

@@ -0,0 +1,52 @@
+import { Database } from './database';
+import FilterParser from './filter-parser';
+
+const db = new Database({
+  dialect: 'sqlite',
+  dialectModule: require('sqlite3'),
+  storage: ':memory:',
+});
+
+(async () => {
+  const User = db.collection({
+    name: 'users',
+    fields: [{ type: 'string', name: 'name' }],
+  });
+
+  const Post = db.collection({
+    name: 'posts',
+    fields: [
+      { type: 'string', name: 'title' },
+      {
+        type: 'belongsTo',
+        name: 'user',
+      },
+    ],
+  });
+
+  await db.sync();
+
+  const repository = User.repository;
+
+  await repository.createMany({
+    records: [
+      { name: 'u1', posts: [{ title: 'u1t1' }] },
+      { name: 'u2', posts: [{ title: 'u2t1' }] },
+      { name: 'u3', posts: [{ title: 'u3t1' }] },
+    ],
+  });
+
+  const Model = User.model;
+  const user = await Model.findOne({
+    subQuery: false,
+    where: {
+      '$posts.title$': 'u1t1',
+    },
+    include: { association: 'posts', attributes: [] },
+    attributes: {
+      include: [],
+    },
+  });
+
+  console.log(user.toJSON());
+})();