vona-module-a-orm 5.0.96 → 5.1.2

package/src/common/buildWhere.ts

@@ -0,0 +1,238 @@
+import type { Knex } from 'knex';
+
+import { isNil } from '@cabloy/utils';
+import { cast } from 'vona';
+
+import type { ServiceDb } from '../service/db_.ts';
+import type { TypeModelColumnValue, TypeModelWhere, TypeModelWhereFieldAll, TypeOpsJoint, TypeOpsNormal } from '../types/modelWhere.ts';
+
+import { Op, OpAggrs, OpJointValues, OpNormalValues } from '../types/modelWhere.ts';
+import { isRaw, isRef } from './utils.ts';
+
+export function buildWhere<TRecord>(db: ServiceDb, builder: Knex.QueryBuilder, wheres: TypeModelWhere<TRecord>, having: boolean = false) {
+  _buildWhereInner(having, db, builder, wheres);
+}
+
+function _buildWhereInner<TRecord>(
+  having: boolean,
+  db: ServiceDb,
+  builder: Knex.QueryBuilder,
+  wheres: TypeModelWhere<TRecord>,
+  column?: keyof TRecord,
+) {
+  // skip
+  if (wheres === Op.skip) {
+    return;
+  }
+  // raw
+  if (isRaw(wheres)) {
+    builder[having ? 'havingRaw' : 'whereRaw'](wheres as Knex.Raw);
+    return;
+  }
+  // loop
+  for (const key in wheres) {
+    const value = wheres[key];
+    if (key[0] !== '_') {
+      // columns
+      _buildWhereColumn(having, db, builder, key, value);
+    } else if (OpNormalValues.includes(key as any)) {
+      // op: normal
+      if (column) {
+        _buildWhereColumn(having, db, builder, column, value, key as any);
+      } else {
+        // not go here
+      }
+    } else {
+      const op = _checkOpJoint(key as any);
+      if (op) {
+        // op: joint
+        _buildWhereOpJoint(having, db, builder, column, value, op);
+      } else {
+        // ignored, not throw error
+      }
+    }
+  }
+}
+
+function _buildWhereOpJoint<TRecord>(
+  having: boolean,
+  db: ServiceDb,
+  builder: Knex.QueryBuilder,
+  column: keyof TRecord | undefined,
+  wheres: TypeModelWhere<TRecord>,
+  op: TypeOpsJoint,
+) {
+  // skip
+  if (wheres === Op.skip) {
+    return;
+  }
+  // and/or
+  if (op === Op.and) {
+    builder[having ? 'having' : 'where'](builder => {
+      for (const key in wheres) {
+        builder.andWhere(builder => {
+          _buildWhereInner(false, db, builder, { [key]: wheres[key] } as any, column);
+        });
+      }
+    });
+    return;
+  }
+  // or
+  if (op === Op.or) {
+    builder[having ? 'having' : 'where'](builder => {
+      for (const key in wheres) {
+        builder.orWhere(builder => {
+          _buildWhereInner(false, db, builder, { [key]: wheres[key] } as any, column);
+        });
+      }
+    });
+    return;
+  }
+  // not
+  if (op === Op.not) {
+    builder[having ? 'havingNot' : 'whereNot'](builder => {
+      _buildWhereInner(false, db, builder, wheres, column);
+    });
+    return;
+  }
+  // exists
+  if (op === Op.exists) {
+    builder[having ? 'havingExists' : 'whereExists'](wheres as any);
+    return;
+  }
+  // notexists
+  if (op === Op.notExists) {
+    builder[having ? 'havingNotExists' : 'whereNotExists'](wheres as any);
+  }
+}
+
+function _buildWhereColumn<TRecord>(
+  having: boolean,
+  db: ServiceDb,
+  builder: Knex.QueryBuilder,
+  column: keyof TRecord,
+  value: TypeModelColumnValue<TRecord, TRecord[keyof TRecord]> | TypeModelWhereFieldAll<TRecord, TRecord[keyof TRecord]>,
+  op?: TypeOpsNormal,
+) {
+  // skip
+  if (value === Op.skip) {
+    return;
+  }
+  // raw
+  if (isRaw(value) || isRef(value)) {
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
+    return;
+  }
+  // null/undefined
+  if (isNil(value)) {
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.is);
+    return;
+  }
+  // array
+  if (Array.isArray(value)) {
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.in);
+    return;
+  }
+  // date
+  if (value instanceof Date) {
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
+    return;
+  }
+  // object
+  if (typeof value === 'object') {
+    builder[having ? 'having' : 'where'](builder => {
+      _buildWhereInner(false, db, builder, value as any, column);
+    });
+    return;
+  }
+  // column
+  _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
+}
+
+function _buildWhereColumnOpNormal<TRecord>(
+  having: boolean,
+  db: ServiceDb,
+  builder: Knex.QueryBuilder,
+  column: keyof TRecord | string,
+  value: any,
+  op: TypeOpsNormal,
+) {
+  column = _checkHavingColumn(db, column) as string;
+  if (op === Op.eq) {
+    builder[having ? 'having' : 'where'](column, '=', value);
+  } else if (op === Op.notEq) {
+    builder[having ? 'having' : 'where'](column, '<>', value);
+  } else if (op === Op.eqI) {
+    builder[_getOpILikeReal(having, db)](column, value);
+  } else if (op === Op.notEqI) {
+    builder[having ? 'havingNot' : 'whereNot']((builder: Knex.QueryBuilder) => {
+      builder[_getOpILikeReal(having, db)](column, value);
+    });
+  } else if (op === Op.gt) {
+    builder[having ? 'having' : 'where'](column, '>', value);
+  } else if (op === Op.gte) {
+    builder[having ? 'having' : 'where'](column, '>=', value);
+  } else if (op === Op.lt) {
+    builder[having ? 'having' : 'where'](column, '<', value);
+  } else if (op === Op.lte) {
+    builder[having ? 'having' : 'where'](column, '<=', value);
+  } else if (op === Op.in) {
+    builder[having ? 'havingIn' : 'whereIn'](column, value);
+  } else if (op === Op.notIn) {
+    builder[having ? 'havingNotIn' : 'whereNotIn'](column, value);
+  } else if (op === Op.is) {
+    builder[having ? 'havingNull' : 'whereNull'](column);
+  } else if (op === Op.isNot) {
+    builder[having ? 'havingNotNull' : 'whereNotNull'](column);
+  } else if (op === Op.between) {
+    builder[having ? 'havingBetween' : 'whereBetween'](column, value);
+  } else if (op === Op.notBetween) {
+    builder[having ? 'havingNotBetween' : 'whereNotBetween'](column, value);
+  } else if (op === Op.startsWith) {
+    builder[_getOpLikeReal(having, db)](column, `${value}%` as any);
+  } else if (op === Op.endsWith) {
+    builder[_getOpLikeReal(having, db)](column, `%${value}` as any);
+  } else if (op === Op.includes) {
+    builder[_getOpLikeReal(having, db)](column, `%${value}%` as any);
+  } else if (op === Op.startsWithI) {
+    builder[_getOpILikeReal(having, db)](column, `${value}%` as any);
+  } else if (op === Op.endsWithI) {
+    builder[_getOpILikeReal(having, db)](column, `%${value}` as any);
+  } else if (op === Op.includesI) {
+    builder[_getOpILikeReal(having, db)](column, `%${value}%` as any);
+  } else if (op === Op.ref) {
+    builder[having ? 'having' : 'where'](column, '=', db.connection.ref(value));
+  }
+}
+
+function _getOpLikeReal(having: boolean, db: ServiceDb) {
+  return db.dialect.capabilities.like ? (having ? 'havingLike' : 'whereLike') : having ? 'havingILike' : 'whereILike';
+}
+
+function _getOpILikeReal(having: boolean, db: ServiceDb) {
+  return db.dialect.capabilities.ilike ? (having ? 'havingILike' : 'whereILike') : having ? 'havingLike' : 'whereLike';
+}
+
+function _checkHavingColumn<TRecord>(db: ServiceDb, column: keyof TRecord | string) {
+  let [aggr, name] = cast<string>(column).split('_');
+  if (!OpAggrs.includes(aggr) || !name) return column;
+  if (aggr === 'count' && name === 'all') name = '*';
+  return db.connection.raw(`${_safeOp(aggr)}(${_safeColumn(name)})`);
+}
+
+function _checkOpJoint(op: TypeOpsJoint) {
+  for (const item of OpJointValues) {
+    if (op.startsWith(item)) {
+      return item;
+    }
+  }
+  return undefined;
+}
+
+function _safeOp(op) {
+  return op.replace(/[\\.*#%'"`;,() ]/g, '');
+}
+
+function _safeColumn(column) {
+  return column.replace(/[\\.#%'"`;,() ]/g, '');
+}

package/src/common/checkWhere.ts

@@ -0,0 +1,128 @@
+// export function checkWhere(where) {
+//   if (where === true || where === false) return where;
+//   if (where === undefined || where === null) {
+//     return true;
+//   }
+//   return where;
+// }
+
+// import { formatValueArray, isRaw } from './utils.ts';
+
+// const __wherePlaceholderOr = '__or__';
+// const __wherePlaceholderAnd = '__and__';
+// const __wherePlaceholderExists = '__exists__';
+// const __wherePlaceholderNotExists = '__notExists__';
+
+// export function checkWhere(where) {
+//   if (where === true || where === false) return where;
+//   if (where === undefined || where === null) {
+//     return true;
+//   }
+//   if (isRaw(where)) {
+//     return where;
+//   }
+//   // loop
+//   const wheres: Array<[key: string, value: any]> = [];
+//   for (const key in where) {
+//     const value = where[key];
+//     // raw
+//     if (isRaw(value)) {
+//       wheres.push([key, value]);
+//       continue;
+//     }
+//     // check key: exists
+//     if (key.includes(__wherePlaceholderExists)) {
+//       wheres.push(['EXISTS', value]);
+//       continue;
+//     }
+//     // check key: not exists
+//     if (key.includes(__wherePlaceholderNotExists)) {
+//       wheres.push(['NOTEXISTS', value]);
+//       continue;
+//     }
+//     // check key: or/and
+//     let keyOrAnd;
+//     if (key.includes(__wherePlaceholderOr)) {
+//       keyOrAnd = 'OR';
+//     } else if (key.includes(__wherePlaceholderAnd)) {
+//       keyOrAnd = 'AND';
+//     }
+//     if (keyOrAnd) {
+//       const _where = _formatOrAnd(value, keyOrAnd);
+//       if (_where === true) {
+//         // ignore
+//       } else if (_where === false) {
+//         // deny
+//         return false;
+//       } else {
+//         wheres.push([keyOrAnd, _where]);
+//       }
+//       continue;
+//     }
+//     // check array
+//     if (Array.isArray(value) && value.length === 0) {
+//       return false;
+//     }
+//     // check object
+//     if (value && !(value instanceof Date) && typeof value === 'object') {
+//       // check array
+//       if (['in', 'notIn'].includes(value.op)) {
+//         const arr = formatValueArray(value);
+//         if (value.op === 'in' && arr === null) return false;
+//         if (value.op === 'notIn' && arr === null) continue;
+//         wheres.push([key, { op: value.op, val: arr }]);
+//         continue;
+//       }
+//     }
+//     // otherwise
+//     wheres.push([key, value]);
+//   }
+//   if (wheres.length === 0) return true;
+//   return wheres;
+// }
+
+// function _formatOrAnd(ors, orAnd) {
+//   // or
+//   if (orAnd === 'OR') {
+//     return _formatOrAnd_or(ors);
+//   }
+//   // and
+//   return _formatOrAnd_and(ors);
+// }
+
+// function _formatOrAnd_or(ors) {
+//   if (ors === undefined || ors === null) return false;
+//   if (!Array.isArray(ors)) ors = [ors];
+//   const wheres: Array<any> = [];
+//   for (const or of ors) {
+//     const _where = checkWhere(or);
+//     if (_where === false) {
+//       // ignore
+//     } else if (_where === true) {
+//       return true;
+//     } else {
+//       wheres.push(_where);
+//     }
+//   }
+//   if (wheres.length === 0) return false;
+//   return wheres;
+// }
+
+// function _formatOrAnd_and(ors) {
+//   if (ors === undefined || ors === null) return true;
+//   if (!Array.isArray(ors)) ors = [ors];
+//   const wheres: Array<any> = [];
+//   for (const or of ors) {
+//     const _where = checkWhere(or);
+//     if (_where === true) {
+//       // ignore
+//     } else if (_where === false) {
+//       // deny
+//       return false;
+//     } else {
+//       wheres.push(_where);
+//     }
+//   }
+//   if (wheres.length === 0) return true;
+//   return wheres;
+// }

package/src/common/index.ts

@@ -0,0 +1,3 @@
+export * from './buildWhere.ts';
+export * from './checkWhere.ts';
+export * from './utils.ts';

package/src/common/utils.ts

@@ -0,0 +1,74 @@
+import type { Constructable } from 'vona';
+
+import { appResource, beanFullNameFromOnionName } from 'vona';
+import { prepareClassType } from 'vona-module-a-openapiutils';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeModelColumn, TypeModelColumns } from '../types/modelWhere.ts';
+import type { IDecoratorModelOptions, IModelClassRecord } from '../types/onion/model.ts';
+
+export function isRaw(raw) {
+  return typeof raw?.constructor === 'function' && raw?.constructor?.name === 'Raw';
+}
+
+export function isRef(ref) {
+  return typeof ref?.constructor === 'function' && ref?.constructor?.name === 'Ref';
+}
+
+export function getTableOrTableAlias(table: string) {
+  const _table = table.toString();
+  return _table.includes(' as ') ? _table.split(' as ')[1].trim() : _table;
+}
+
+export function getTargetColumnName(column: string) {
+  if (column.includes(' as ')) return column.split(' as ')[1].trim();
+  if (column.includes('.')) return column.split('.')[1].trim();
+  return column;
+}
+
+export function prepareColumns<TRecord>(columns?: TypeModelColumns<TRecord>): Array<TypeModelColumn<TRecord>> | undefined {
+  if (!columns) return undefined;
+  columns = Array.isArray(columns) ? columns : [columns];
+  if (columns.includes('*')) return undefined;
+  return columns;
+}
+
+export function prepareClassModel<ModelLike extends BeanModelMeta | keyof IModelClassRecord>(
+  classType: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+): Constructable<ModelLike> {
+  if (typeof classType === 'string') {
+    const beanOptions = appResource.getBean(beanFullNameFromOnionName(classType, 'model'));
+    return beanOptions!.beanClass as any;
+  }
+  return prepareClassType(classType) as any;
+}
+
+export function getClassEntityFromClassModel<T>(modelClass: Constructable<T>) {
+  const beanOptions = appResource.getBean(modelClass);
+  const options: IDecoratorModelOptions = beanOptions!.options!;
+  return options.entity!;
+}
+
+// export function formatValue(value) {
+//   if (typeof value !== 'object' || value instanceof Date) return value;
+//   // date
+//   if (value.type === 'Date') return moment(value.val).toDate();
+//   // like
+//   if (value.op === 'like') return `%${value.val}%`;
+//   if (value.op === 'likeLeft') return `%${value.val}`;
+//   if (value.op === 'likeRight') return `${value.val}%`;
+//   if (value.op === 'likeStrict') return `${value.val}`;
+//   // in
+//   if (['in', 'notIn'].includes(value.op)) {
+//     return formatValueArray(value);
+//   }
+//   // others
+//   return value.val;
+// }
+
+// export function formatValueArray(value) {
+//   if (!value.val) return null;
+//   const arr = typeof value.val === 'string' ? value.val.split(',') : value.val;
+//   if (arr.length === 0) return null;
+//   return arr;
+// }

package/src/config/config.ts

@@ -0,0 +1,60 @@
+import type { TableIdentityType } from 'table-identity';
+import type { VonaApplication } from 'vona';
+import type { IOnionOptionsMeta } from 'vona-module-a-onion';
+import type { TSummerCachePreset } from 'vona-module-a-summer';
+
+import { configAll, configRedis } from 'vona-module-a-summer';
+
+import type { IDataBaseConfigDialects } from '../types/config.ts';
+
+export function config(_app: VonaApplication) {
+  return {
+    sharding: {
+      cache: {
+        doubleDelete: true,
+      },
+    },
+    rest: {
+      query: {
+        pageSize: {
+          default: 20,
+          max: 100,
+        },
+        orders: {
+          default: 'createdAt,desc',
+        },
+      },
+    },
+    table: {
+      identityType: 'bigint' as TableIdentityType,
+    },
+    model: {
+      disableDeleted: false,
+      disableInstance: false,
+      disableCreateTime: false,
+      disableUpdateTime: false,
+    },
+    softDeletionPrune: {
+      enable: true,
+      expired: 14 * 24 * 3600 * 1000,
+    },
+    dialects: {
+      'better-sqlite3': 'a-ormdialect:betterSqlite3',
+      'mysql': 'a-ormdialect:mysql',
+      'mysql2': 'a-ormdialect:mysql3',
+      'pg': 'a-ormdialect:pg',
+    } as IDataBaseConfigDialects,
+    summer: {
+      enable: true,
+      meta: {} as IOnionOptionsMeta,
+      presetDefault: 'redis' as TSummerCachePreset,
+      preset: {
+        redis: configRedis,
+        all: configAll,
+      },
+      redis: {
+        client: 'model',
+      },
+    },
+  };
+}

package/src/config/errors.ts

@@ -0,0 +1,3 @@
+export const errors = {
+  ShouldSpecifyTable: 1001,
+} as const;

package/src/config/locale/en-us.ts

@@ -0,0 +1,8 @@
+export default {
+  TableIdentity: 'ID',
+  CreatedAt: 'Created At',
+  UpdatedAt: 'Updated At',
+  Deleted: 'Deleted',
+  InstanceId: 'Instance ID',
+  ShouldSpecifyTable: 'should specify the table name',
+};

package/src/config/locale/zh-cn.ts

@@ -0,0 +1,8 @@
+export default {
+  TableIdentity: '标识',
+  CreatedAt: '创建时间',
+  UpdatedAt: '修改时间',
+  Deleted: '已删除',
+  InstanceId: '实例标识',
+  ShouldSpecifyTable: '应该指定表名',
+};

package/src/extend/index.ts

@@ -0,0 +1,12 @@
+import type { VonaApplication } from 'vona';
+
+import { ExtendSchemaBuilder } from './schemaBuilder.ts';
+import { ExtendTableBuilder } from './tableBuilder.ts';
+
+export * from './schemaBuilder.ts';
+export * from './tableBuilder.ts';
+
+export function ExtendKnex(app: VonaApplication) {
+  ExtendSchemaBuilder(app);
+  ExtendTableBuilder(app);
+}

package/src/extend/schemaBuilder.ts

@@ -0,0 +1,29 @@
+import type { Knex } from 'knex';
+import type { VonaApplication } from 'vona';
+
+import knex from 'knex';
+import { cast } from 'vona';
+
+import type { IDatabaseClientDialectRecord } from '../types/database.ts';
+import type { IFetchDatabasesResultItem, IFetchIndexesResultItem } from '../types/dialect.ts';
+
+export function ExtendSchemaBuilder(app: VonaApplication) {
+  ['fetchDatabases', 'createDatabase', 'dropDatabase', 'fetchIndexes'].forEach(method => {
+    knex.SchemaBuilder.extend(method, async function (...args) {
+      const client = cast<Knex.Client>(cast(this).client).config.client as keyof IDatabaseClientDialectRecord;
+      const dialect = app.bean.database.getDialect(client);
+      return await dialect[method](this, ...args);
+    });
+  });
+}
+
+declare module 'knex' {
+  namespace Knex {
+    interface SchemaBuilder {
+      fetchDatabases(databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
+      createDatabase(databaseName: string): Promise<string>;
+      dropDatabase(databaseName: string): Promise<void>;
+      fetchIndexes(tableName: string): Promise<IFetchIndexesResultItem[]>;
+    }
+  }
+}

package/src/extend/tableBuilder.ts

@@ -0,0 +1,87 @@
+import type { TableIdentityType } from 'table-identity';
+import type { VonaApplication } from 'vona';
+
+import knex from 'knex';
+
+import { __ThisModule__ } from '../.metadata/this.ts';
+
+export interface IBasicFieldsOptions {
+  id?: boolean;
+  timestamps?: boolean;
+  deleted?: boolean;
+  iid?: boolean;
+}
+
+export function ExtendTableBuilder(app: VonaApplication) {
+  const scope = app.scope(__ThisModule__);
+  function _basicFields(this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions, identityType?: TableIdentityType) {
+    options = options || ({} as IBasicFieldsOptions);
+    if (options.id !== false) {
+      const _identityType = identityType ?? scope.config.table.identityType;
+      if (_identityType === 'bigint') {
+        this.bigIncrements();
+      } else if (_identityType === 'number') {
+        this.increments();
+      } else {
+        throw new Error('Should create column id by yourself');
+      }
+    }
+    if (options.timestamps !== false) this.timestamps(true, true, true);
+    if (options.deleted !== false) this.boolean('deleted').defaultTo(false);
+    if (options.iid !== false) this.integer('iid').defaultTo(0);
+    return this;
+  }
+
+  knex.TableBuilder.extend('basicFields', function (this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions) {
+    _basicFields.call(this, options, undefined);
+    return this;
+  });
+  knex.TableBuilder.extend('basicFieldsSimple', function (this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions) {
+    _basicFields.call(this, options, 'number');
+    return this;
+  });
+  knex.TableBuilder.extend('tableIdentity', function (this: knex.Knex.TableBuilder, columnName: string) {
+    const _identityType = scope.config.table.identityType;
+    if (_identityType === 'bigint') {
+      return this.bigInteger(columnName); // default value is null
+    } else if (_identityType === 'number') {
+      return this.integer(columnName); // default value is null
+    } else {
+      throw new Error(`Should create column ${columnName} by yourself`);
+    }
+  });
+  knex.TableBuilder.extend('userId', function (this: knex.Knex.TableBuilder, columnName?: string) {
+    return this.tableIdentity(columnName ?? 'userId');
+  });
+  knex.TableBuilder.extend('int0', function (this: knex.Knex.TableBuilder, columnName: string) {
+    return this.integer(columnName).defaultTo(0);
+  });
+  knex.TableBuilder.extend('int1', function (this: knex.Knex.TableBuilder, columnName: string) {
+    return this.integer(columnName).defaultTo(1);
+  });
+  ['description'].forEach(method => {
+    knex.TableBuilder.extend(method, function (this: knex.Knex.TableBuilder, length: number = 255) {
+      return this.string(method, length);
+    });
+  });
+  ['content'].forEach(method => {
+    knex.TableBuilder.extend(method, function (this: knex.Knex.TableBuilder, useText?: boolean) {
+      return useText ? this.text(method) : this.json(method);
+    });
+  });
+}
+
+declare module 'knex' {
+  namespace Knex {
+    interface TableBuilder {
+      basicFields(options?: IBasicFieldsOptions): Knex.TableBuilder;
+      basicFieldsSimple(options?: IBasicFieldsOptions): Knex.TableBuilder;
+      tableIdentity(columnName?: string): Knex.ColumnBuilder;
+      userId(columnName?: string): Knex.ColumnBuilder;
+      int0(columnName: string): Knex.ColumnBuilder;
+      int1(columnName: string): Knex.ColumnBuilder;
+      description(length?: number): Knex.ColumnBuilder;
+      content(useText?: boolean): Knex.ColumnBuilder;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import 'bignumber.js';
+
+export * from './.metadata/index.ts';
+
+export * from './.metadata/locales.ts';
+export * from './bean/bean.model/bean.model_meta.ts';
+export * from './common/index.ts';
+export * from './extend/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';