@asapjs/sequelize 0.0.2 → 0.0.6

package/src/type/index.ts

@@ -0,0 +1,263 @@
+import { BlobSize, DataTypes, TextLength } from 'sequelize';
+import isClass from 'src/utils/isClass';
+import { ExtendableDto } from '../dto';
+
+const data: { [key: string]: any } = {};
+
+export const getTypesData = (target: any) => {
+  const values = data[target?.name || target?.constructor?.name];
+  if (!values) return {};
+  return values;
+};
+
+export const saveNewTypesData = (attributes: any, target: any) => {
+  data[target.constructor.name] = attributes;
+};
+
+export const saveTypesData = (target: any, propertyName: any, value: any) => {
+  const types = getTypesData(target);
+
+  types[propertyName] = value;
+
+  saveNewTypesData(types, target);
+};
+
+type TypeIsData = {
+  __name: string;
+  toSwagger?: (...args: any[]) => any;
+  toSequelize?: (...args: any[]) => any;
+  fixValue?: (o: any) => any;
+};
+
+const typeGenerator =
+  (data: (...args: any[]) => TypeIsData) =>
+  (...options: any) => {
+    return (target?: any, propertyName?: string, propertyDescriptor?: PropertyDescriptor): void & TypeIsData => {
+      if (target !== undefined) {
+        const type = data(...options);
+
+        saveTypesData(target, propertyName, type);
+
+        if (propertyDescriptor) {
+          propertyDescriptor.value = type;
+        }
+      } else {
+        return data(...options) as any;
+      }
+    };
+  };
+
+export const TypeIs = {
+  INT: typeGenerator((options?: { decimals?: number; precision?: number; scale?: number; comment?: string }) => ({
+    __name: 'int',
+    toSwagger: () => ({
+      type: 'integer',
+      format: 'int32',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.INTEGER(options), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return parseInt(String(o), 10);
+    },
+  })),
+  LONG: typeGenerator((options?: { decimals?: number; precision?: number; scale?: number; comment?: string }) => ({
+    __name: 'long',
+    toSwagger: () => ({
+      type: 'integer',
+      format: 'int64',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.INTEGER(options), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return parseInt(String(o), 10);
+    },
+  })),
+  FLOAT: typeGenerator((options: { length?: number; decimals?: number; comment?: string }) => ({
+    __name: 'float',
+    toSwagger: () => ({
+      type: 'integer',
+      format: 'float',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.FLOAT(options?.length, options?.decimals), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return parseFloat(String(o));
+    },
+  })),
+  DOUBLE: typeGenerator((options: { length?: number; decimals?: number; comment?: string }) => ({
+    __name: 'double',
+    toSwagger: () => ({
+      type: 'number',
+      format: 'double',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.DOUBLE(options?.length, options?.decimals), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return parseFloat(String(o));
+    },
+  })),
+  STRING: typeGenerator((options: { length?: number; binary?: boolean; comment?: string }) => ({
+    __name: 'string',
+    toSwagger: () => ({
+      type: 'string',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.STRING(options?.length, options?.binary), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return String(o);
+    },
+  })),
+  TEXT: typeGenerator((options: { length?: TextLength; comment?: string }) => ({
+    __name: 'text',
+    toSwagger: () => ({
+      type: 'string',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.TEXT({ length: options?.length }), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return String(o);
+    },
+  })),
+  PASSWORD: typeGenerator((options: { comment?: string }) => ({
+    __name: 'password',
+    toSwagger: () => ({
+      type: 'string',
+      format: 'password',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.STRING(512), comment: options?.comment }),
+  })),
+  ENUM: typeGenerator((options: { values: string[]; comment?: string }) => ({
+    __name: 'enum',
+    toSwagger: () => ({
+      type: 'string',
+      enum: options?.values,
+      description: options?.values?.[0],
+    }),
+    toSequelize: () => ({ type: DataTypes.ENUM({ values: options?.values }), comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return options?.values?.includes?.(String(o)) ? String(o) : undefined;
+    },
+  })),
+  JSON: typeGenerator((options: { comment?: string }) => ({
+    __name: 'json',
+    toSwagger: () => ({
+      type: 'object',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.JSON, comment: options?.comment }),
+  })),
+  BASE64: typeGenerator((options: { length?: BlobSize; comment?: string }) => ({
+    __name: 'base64',
+    toSwagger: () => ({
+      type: 'string',
+      format: 'byte',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.BLOB(options?.length), comment: options?.comment }),
+  })),
+  BINARY: typeGenerator((options: { length?: BlobSize; comment?: string }) => ({
+    __name: 'binary',
+    toSwagger: () => ({
+      type: 'string',
+      format: 'binary',
+      description: options?.comment,
+    }),
+    toSequelize: () => ({ type: DataTypes.BLOB(options?.length), comment: options?.comment }),
+  })),
+  BOOLEAN: typeGenerator((options: { comment?: string }) => ({
+    __name: 'boolean',
+    toSwagger: () => ({
+      type: 'boolean',
+    }),
+    toSequelize: () => ({ type: DataTypes.BOOLEAN, comment: options?.comment }),
+    fixValue: (o: any) => {
+      if (o === undefined || o === null) return o;
+      return String(o) === 'true' ? true : String(o) === 'false' ? false : !!o;
+    },
+  })),
+  DATEONLY: typeGenerator((options: { comment?: string }) => ({
+    __name: 'date',
+    toSwagger: () => ({
+      type: 'string',
+      format: 'date',
+      description: options?.comment,
+    }),
+    toSequelize: () => DataTypes.DATEONLY(),
+  })),
+  DATETIME: typeGenerator((options: { comment?: string }) => ({
+    __name: 'datetime',
+    toSwagger: () => ({
+      type: 'string',
+      format: 'date-time',
+      description: options?.comment,
+    }),
+    toSequelize: () => DataTypes.DATE,
+  })),
+  FOREIGNKEY: typeGenerator((table: any) => ({
+    __name: 'foreignkey',
+    toSequelize: () => table,
+  })),
+  BELONGSTO: typeGenerator((associatedClassGetter: any, optionsOrForeignKey: any) => ({
+    __name: 'belongsto',
+    toSequelize: () => ({
+      associatedClassGetter,
+      optionsOrForeignKey,
+    }),
+  })),
+  DTO: typeGenerator((options: { dto: any; comment?: string }) => ({
+    __name: 'dto',
+    toSwagger: () => {
+      const result = new (options?.dto)()?.swagger();
+      return { ...result, comment: options?.comment };
+    },
+  })),
+};
+
+// export const TypeArray = (options: { dto?: typeof ExtendableDto; type?: TypeIsData; comment?: string }) => {
+//   return {
+//     __name: 'array',
+//     toSwagger: () => ({
+//       type: 'array',
+//       items: options?.dto ? new options.dto()?.swagger() : options?.type ? options?.type?.toSwagger?.() : null,
+//       description: options?.comment,
+//     }),
+//   };
+// };
+
+// export const TypeArray = (options: { dto?: typeof ExtendableDto; type?: () => TypeIsData; comment?: string }) => {
+//   return class {
+//     public swagger = () => {
+//       return {
+//         type: 'array',
+//         items: options?.dto ? new options.dto()?.swagger() : options?.type ? options?.type?.()?.toSwagger?.() : null,
+//         description: options?.comment,
+//       };
+//     };
+//   };
+// };
+
+export type DtoOrTypeIs = typeof ExtendableDto | (() => TypeIsData);
+
+export const TypeArray = (value: DtoOrTypeIs) => {
+  return class {
+    public swagger = () => {
+      const isDto = isClass(value);
+
+      return {
+        type: 'array',
+        items: isDto
+          ? new (value as typeof ExtendableDto)()?.swagger()
+          : (value as () => TypeIsData)?.()?.toSwagger?.(),
+        // description: options?.comment,
+      };
+    };
+  };
+};

package/src/{util → utils}/getUserIdInQuery.ts

@@ -1 +1 @@
-export const getUserIdInQuery = (user?: any) => `"${user?.id || ''}"`;
+export const getUserIdInQuery = (user?: any) => `"${user?.id || user?._id || ''}"`;

package/src/utils/isClass.ts

@@ -0,0 +1 @@
+export default (v: any) => v?.prototype?.constructor !== undefined;

package/dist/util/getUserIdInQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getUserIdInQuery.d.ts","sourceRoot":"","sources":["../../src/util/getUserIdInQuery.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,UAAW,GAAG,WAA0B,CAAC"}

package/dist/util/getUserIdInQuery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getUserIdInQuery.js","sourceRoot":"","sources":["../../src/util/getUserIdInQuery.ts"],"names":[],"mappings":";;;AAAO,MAAM,gBAAgB,GAAG,CAAC,IAAU,EAAE,EAAE,CAAC,IAAI,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,EAAE,KAAI,EAAE,GAAG,CAAC;AAAzD,QAAA,gBAAgB,oBAAyC"}