easywork-common-lib 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/eslint.config.js

@@ -0,0 +1,45 @@
+const rubiin = require("@antfu/eslint-config").default;
+
+module.exports = rubiin({
+  stylistic: {
+    semi: true,
+    quotes: "double",
+  }, // enable stylistic rules
+  yaml: true, // enable yaml rules,
+  jsonc: true, // enable jsonc rules
+  markdown: false, // enable markdown rules
+  gitignore: true, // enable gitignore rules,
+  typescript: {
+    tsconfigPath: "tsconfig.json",
+  },
+  overrides: {
+    test: {
+      "ts/unbound-method": "off",
+    },
+    typescript: {
+      "ts/no-misused-promises": [
+        "error",
+        {
+          checksVoidReturn: false,
+        },
+      ],
+      "ts/no-floating-promises": [
+        "error",
+        {
+          ignoreIIFE: true,
+        },
+      ],
+      "unicorn/prefer-top-level-await": "off",
+      "unicorn/prevent-abbreviations": [
+        "error",
+        {
+          ignore: ["\\.e2e*", "\\.spec*", "\\.decorator*", "\\*idx*"],
+          allowList: {
+            ProcessEnv: true,
+            UUIDParam: true,
+          },
+        },
+      ],
+    },
+  },
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "easywork-common-lib",
+  "version": "1.0.0",
+  "description": "Paquete de librerías compartidas para EasyWork",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "nestjs",
+    "typeorm",
+    "shared",
+    "entities"
+  ],
+  "author": "Rosmer Campos",
+  "license": "MIT",
+  "dependencies": {
+    "@nestjs/common": "^10.3.8",
+    "@nestjs/typeorm": "^10.0.2",
+    "@rubiin/tsconfig": "^1.1.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "typeorm": "^0.2.45"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.2"
+  }
+}

package/src/common/@types/typings/globals.d.ts

@@ -0,0 +1,13 @@
+import type { NextFunction, Request, Response } from "express";
+
+/* The `export {};` statement is used to indicate that the file is a module and exports nothing. It is
+often used in TypeScript files that only contain type declarations or interfaces, without any actual
+code or exports. This statement ensures that the file is treated as a module and not as a script. */
+export {};
+
+declare global {
+  // Using this allows is to quickly switch between express and fastify and others
+  export type NestifyRequest = Request;
+  export type NestifyResponse = Response;
+  export type NestifyNextFunction = NextFunction;
+}

package/src/common/database/base.entity.ts

@@ -0,0 +1,30 @@
+import {
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  BaseEntity as EntityBase,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from "typeorm";
+
+@Entity()
+export abstract class BaseEntity extends EntityBase {
+  @PrimaryGeneratedColumn("uuid")
+  id?: string;
+
+  @Column({ default: true })
+  isActive?: boolean;
+
+  @Column({ default: false })
+  isDeleted?: boolean;
+
+  @CreateDateColumn()
+  createdAt?: Date;
+
+  @UpdateDateColumn()
+  updatedAt?: Date;
+
+  @DeleteDateColumn()
+  deletedAt?: Date;
+}

package/src/common/database/index.ts

@@ -0,0 +1 @@
+export * from "./base.entity";

package/src/entities/group.entity.ts

@@ -0,0 +1,10 @@
+import { BaseEntity } from "@common/database";
+import { MinLength } from "class-validator";
+import { Column, Entity } from "typeorm";
+
+@Entity()
+export class Group extends BaseEntity {
+  @MinLength(3)
+  @Column({ unique: true })
+  name: string;
+}

package/src/entities/index.ts

@@ -0,0 +1,7 @@
+export * from "./user.entity";
+export * from "./protocol.entity";
+export * from "./otp-log.entity";
+export * from "./refresh-token.entity";
+export * from "./profile.entity";
+export * from "./role.entity";
+export * from "./permission.entity";

package/src/entities/otp-log.entity.ts

@@ -0,0 +1,20 @@
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+import { BaseEntity } from "@common/database";
+import { User } from "./user.entity";
+
+@Entity()
+@Index(["otpCode"], { unique: true })
+export class OtpLog extends BaseEntity {
+  @Column({ type: "timestamp" })
+  expiresIn!: Date;
+
+  @Column({ length: 20, nullable: true })
+  otpCode?: string;
+
+  @ManyToOne(() => User, { eager: false, nullable: false })
+  @JoinColumn()
+  user!: User;
+
+  @Column({ default: false })
+  isUsed?: boolean;
+}

package/src/entities/permission.entity.ts

@@ -0,0 +1,20 @@
+import { BaseEntity } from "@common/database";
+import { Column, Entity, Index, JoinTable, ManyToMany } from "typeorm";
+import { Role } from "./role.entity";
+
+@Entity()
+@Index(["resource", "action"], { unique: true })
+export class Permission extends BaseEntity {
+  @Column()
+  resource: string;
+
+  @Column()
+  action: string;
+
+  @ManyToMany(() => Role, {
+    onDelete: "CASCADE",
+    onUpdate: "CASCADE",
+  })
+  @JoinTable()
+  roles?: Role[];
+}

package/src/entities/profile.entity.ts

@@ -0,0 +1,24 @@
+import { BaseEntity } from "@common/database";
+import { Column, Entity, OneToOne } from "typeorm";
+import { User } from "./user.entity";
+
+@Entity("user_profile")
+export class Profile extends BaseEntity {
+  @Column()
+  firstName: string;
+
+  @Column()
+  lastName: string;
+
+  @Column({ unique: true })
+  idcard: string;
+
+  @Column({ nullable: true })
+  birthday: Date;
+
+  @OneToOne(() => User, user => user.profile, {
+    onDelete: "CASCADE",
+    onUpdate: "CASCADE",
+  })
+  user: User;
+}

package/src/entities/protocol.entity.ts

@@ -0,0 +1,24 @@
+import { Column, Entity } from "typeorm";
+import { BaseEntity } from "@common/database";
+
+// Usa este modelo para almacenar el protocolo
+
+@Entity()
+export class Protocol extends BaseEntity {
+  @Column()
+  loginAttemptInterval!: number;
+
+  @Column()
+  loginIntervalUnit!: string;
+
+  @Column()
+  loginMaxRetry!: number;
+
+  @Column()
+  otpExpiryInMinutes!: number;
+
+  constructor(partial?: Partial<Protocol>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

package/src/entities/refresh-token.entity.ts

@@ -0,0 +1,24 @@
+import { Column, Entity, ManyToOne } from "typeorm";
+import { BaseEntity } from "@common/database";
+import { User } from "./user.entity";
+
+@Entity()
+export class RefreshToken extends BaseEntity {
+  @Column()
+  expiresIn!: Date;
+
+  @ManyToOne(() => User, {
+    eager: false,
+    onDelete: "CASCADE",
+    onUpdate: "CASCADE",
+  })
+  user!: User;
+
+  @Column({ default: false })
+  isRevoked?: boolean;
+
+  constructor(partial?: Partial<RefreshToken>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

package/src/entities/role.entity.ts

@@ -0,0 +1,13 @@
+import { BaseEntity } from "@common/database";
+import { MinLength } from "class-validator";
+import { Column, Entity } from "typeorm";
+
+@Entity()
+export class Role extends BaseEntity {
+  @MinLength(3)
+  @Column({ unique: true })
+  name: string;
+
+  @Column({ default: false })
+  isDefault: boolean;
+}

package/src/entities/user.entity.ts

@@ -0,0 +1,54 @@
+import { BaseEntity } from "@common/database";
+import { Column, Entity, JoinColumn, JoinTable, ManyToMany, OneToOne } from "typeorm";
+import { Exclude } from "class-transformer";
+import { Profile } from "./profile.entity";
+import { Role } from "./role.entity";
+
+@Entity()
+export class User extends BaseEntity {
+  @Column({ unique: true })
+  username!: string;
+
+  @Column({ unique: true })
+  email!: string;
+
+  @Column({ type: "text" })
+  bio!: string;
+
+  @Column({ type: "text" })
+  avatar!: string;
+
+  @Exclude()
+  @Column({ type: "text" })
+  hash!: string;
+
+  @Exclude()
+  @Column({ nullable: true })
+  twoFactorSecret?: string;
+
+  @Column({ default: false })
+  isTwoFactorEnabled?: boolean;
+
+  @Column({ unique: true })
+  phone?: string;
+
+  @Column({ default: false })
+  isVerified?: boolean;
+
+  @Column({ type: "timestamp", nullable: true })
+  lastLogin?: Date;
+
+  @OneToOne(() => Profile, {
+    onDelete: "CASCADE",
+    onUpdate: "CASCADE",
+  })
+  @JoinColumn()
+  profile: Profile;
+
+  @ManyToMany(() => Role, {
+    onDelete: "CASCADE",
+    onUpdate: "CASCADE",
+  })
+  @JoinTable()
+  roles?: Role[];
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts", "eslint.config.js"]
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "extends": "@rubiin/tsconfig",
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./src",
+    "incremental": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": true,
+    "paths": {
+      "@common/*": ["./common/*"],
+      "@entities": ["./entities"]
+    },
+    "noFallthroughCasesInSwitch": false
+  },
+  "include": ["test/**/*", "src/**/*", "eslint.config.js"],
+  "typeRoots": ["./src/common/@types/typings"]
+}