@ainias42/typeorm-helper 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainias42/typeorm-helper",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -15,7 +15,9 @@
     "lint:noCache": "eslint \"src/{**/*,*}.{js,jsx,tsx,ts}\" --max-warnings 0",
     "lint": "npm run lint:noCache -- --cache",
     "lint:fix": "npm run lint -- --fix",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prettier": "npm run prettier:list -- --write",
+    "prettier:list": "prettier --list-different \"src/**/*.{ts,tsx,js,jsx,json}\""
   },
   "author": "",
   "repository": {
@@ -23,6 +25,7 @@
     "url": "gitea@git.silas.link:Ainias/libraries.git"
   },
   "dependencies": {
+    "@ainias42/config": "*",
     "@ainias42/js-helper": ">=0.8.15",
     "typeorm": "^0.3.20",
     "reflect-metadata": "^0.2.2"

package/src/BaseModel.ts

@@ -1,18 +1,19 @@
-import { CreateDateColumn, DeleteDateColumn, PrimaryGeneratedColumn, UpdateDateColumn, VersionColumn } from "typeorm";
+import { CreateDateColumn, DeleteDateColumn, PrimaryGeneratedColumn, UpdateDateColumn, VersionColumn } from 'typeorm';
+import { DateHelper } from '@ainias42/js-helper';
 
 export class BaseModel {
     @PrimaryGeneratedColumn()
     id: number = -1;
 
     @CreateDateColumn()
-    createdAt?: Date;
+    createdAt: Date = DateHelper.newDate();
 
     @UpdateDateColumn()
-    updatedAt?: Date;
+    updatedAt: Date = DateHelper.newDate();
 
     @DeleteDateColumn()
-    deletedAt?: Date;
+    deletedAt: Date | null = null;
 
     @VersionColumn()
-    version?: number;
+    version: number = 0;
 }

package/src/DbNamingStrategy.ts

@@ -1,63 +1,45 @@
-import { DefaultNamingStrategy } from "typeorm";
-import type { NamingStrategyInterface, Table } from "typeorm";
+import { DefaultNamingStrategy } from 'typeorm';
+import type { NamingStrategyInterface, Table } from 'typeorm';
 
 export class DbNamingStrategy extends DefaultNamingStrategy implements NamingStrategyInterface {
-
     private createKey(prefix: string, tableOrName: Table | string, columnNames: string[], suffix?: string): string {
         const clonedColumnNames = [...columnNames];
         clonedColumnNames.sort();
         const tableName = this.getTableName(tableOrName);
-        const replacedTableName = tableName.replace(".", "_");
-        let key = `${prefix}_${replacedTableName}_${clonedColumnNames.join("_")}`;
-        if (suffix){
+        const replacedTableName = tableName.replace('.', '_');
+        let key = `${prefix}_${replacedTableName}_${clonedColumnNames.join('_')}`;
+        if (suffix) {
             key += `_${suffix}`;
         }
         return key;
     }
 
     indexName(tableOrName: Table | string, columnNames: string[], where?: string): string {
-        return this.createKey("IDX", tableOrName, columnNames, where);
+        return this.createKey('IDX', tableOrName, columnNames, where);
     }
 
-    foreignKeyName(
-        tableOrName: Table | string,
-        columnNames: string[],
-    ): string {
-        return this.createKey("FK", tableOrName, columnNames);
+    foreignKeyName(tableOrName: Table | string, columnNames: string[]): string {
+        return this.createKey('FK', tableOrName, columnNames);
     }
 
-    uniqueConstraintName(
-        tableOrName: Table | string,
-        columnNames: string[],
-    ): string {
+    uniqueConstraintName(tableOrName: Table | string, columnNames: string[]): string {
         // There is a bug in the cli. They use the indexName method to generate unique constraint names
-        return this.createKey("IDX", tableOrName, columnNames);
+        return this.createKey('IDX', tableOrName, columnNames);
     }
 
     primaryKeyName(tableOrName: Table | string, columnNames: string[]): string {
-        return this.createKey("PK", tableOrName, columnNames);
+        return this.createKey('PK', tableOrName, columnNames);
     }
 
-    relationConstraintName(
-        tableOrName: Table | string,
-        columnNames: string[],
-        where?: string,
-    ): string {
-        return this.createKey("REL", tableOrName, columnNames, where);
+    relationConstraintName(tableOrName: Table | string, columnNames: string[], where?: string): string {
+        return this.createKey('REL', tableOrName, columnNames, where);
     }
 
-    checkConstraintName(
-        tableOrName: Table | string,
-        expression: string,
-        isEnum?: boolean,
-    ): string {
-        return this.createKey("CHK", tableOrName, [expression], isEnum ? "ENUM" : undefined);
+    checkConstraintName(tableOrName: Table | string, expression: string, isEnum?: boolean): string {
+        return this.createKey('CHK', tableOrName, [expression], isEnum ? 'ENUM' : undefined);
     }
 
-    exclusionConstraintName(
-        tableOrName: Table | string,
-        expression: string,
-    ): string {
-        return this.createKey("XCL", tableOrName, [expression]);
+    exclusionConstraintName(tableOrName: Table | string, expression: string): string {
+        return this.createKey('XCL', tableOrName, [expression]);
     }
 }

package/src/DefaultSubscriber.ts

@@ -1,20 +1,19 @@
 /* eslint-disable class-methods-use-this */
-import { ColumnMetadata } from "typeorm/metadata/ColumnMetadata";
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
 import {
     EntitySubscriberInterface,
     EventSubscriber,
     InsertEvent,
     ObjectLiteral,
     OptimisticLockVersionMismatchError,
-    UpdateEvent
-} from "typeorm";
-import { FileTransformer } from "./decorators/FileColumn/FileTransformer";
-import { FileType } from "./decorators/FileColumn/FileType";
-import { FileWriter } from "./decorators/FileColumn/FileWriter";
+    UpdateEvent,
+} from 'typeorm';
+import { FileTransformer } from './decorators/FileColumn/FileTransformer';
+import { FileType } from './decorators/FileColumn/FileType';
+import { FileWriter } from './decorators/FileColumn/FileWriter';
 
 @EventSubscriber()
 export class DefaultSubscriber implements EntitySubscriberInterface {
-
     async saveFiles(entity: ObjectLiteral, columns: ColumnMetadata[]) {
         const promises = [];
         for (const column of columns) {
@@ -27,15 +26,23 @@ export class DefaultSubscriber implements EntitySubscriberInterface {
                         values = [values];
                         single = true;
                     }
-                    promises.push(Promise.all(values.map(value => FileWriter.writeToFile(value.src, transformer.fileOptions.saveDirectory).then(newUrl => {
-                        return {...value, src: newUrl};
-                    }))).then(newValues => {
-                        if (single) {
-                            Reflect.set(entity, column.propertyName, newValues[0]);
-                        } else {
-                            Reflect.set(entity, column.propertyName, newValues);
-                        }
-                    }));
+                    promises.push(
+                        Promise.all(
+                            values.map((value) =>
+                                FileWriter.writeToFile(value.src, transformer.fileOptions.saveDirectory).then(
+                                    (newUrl) => {
+                                        return { ...value, src: newUrl };
+                                    },
+                                ),
+                            ),
+                        ).then((newValues) => {
+                            if (single) {
+                                Reflect.set(entity, column.propertyName, newValues[0]);
+                            } else {
+                                Reflect.set(entity, column.propertyName, newValues);
+                            }
+                        }),
+                    );
                 }
             }
         }
@@ -45,12 +52,12 @@ export class DefaultSubscriber implements EntitySubscriberInterface {
     /**
      * Called before post insertion.
      */
-    async beforeInsert({entity, metadata: {columns}}: InsertEvent<any>) {
+    async beforeInsert({ entity, metadata: { columns } }: InsertEvent<any>) {
         if (entity) {
-            Reflect.set(entity, "updatedAt", new Date());
-            Reflect.set(entity, "createdAt", new Date());
-            if (Reflect.get(entity, "id") <= 0) {
-                Reflect.set(entity, "id", undefined);
+            Reflect.set(entity, 'updatedAt', new Date());
+            Reflect.set(entity, 'createdAt', new Date());
+            if (Reflect.get(entity, 'id') <= 0) {
+                Reflect.set(entity, 'id', undefined);
             }
 
             await this.saveFiles(entity, columns);
@@ -65,10 +72,7 @@ export class DefaultSubscriber implements EntitySubscriberInterface {
         // is defined in the metadatas of that entity.
         if (event.metadata.versionColumn && event.entity && event.databaseEntity) {
             // Getting the current version of the requested entity update
-            const versionFromUpdate = Reflect.get(
-                event.entity,
-                event.metadata.versionColumn.propertyName
-            );
+            const versionFromUpdate = Reflect.get(event.entity, event.metadata.versionColumn.propertyName);
 
             // Getting the entity's version from the database
             const versionFromDatabase = event.databaseEntity[event.metadata.versionColumn.propertyName];
@@ -78,17 +82,17 @@ export class DefaultSubscriber implements EntitySubscriberInterface {
                 throw new OptimisticLockVersionMismatchError(
                     event.metadata.name,
                     versionFromDatabase,
-                    versionFromUpdate
+                    versionFromUpdate,
                 );
             }
         }
 
         if (event.entity) {
-            Reflect.set(event.entity, "updatedAt", new Date());
+            Reflect.set(event.entity, 'updatedAt', new Date());
         }
 
-        const {columns} = event.metadata;
-        const {entity} = event;
+        const { columns } = event.metadata;
+        const { entity } = event;
         if (entity) {
             await this.saveFiles(entity, columns);
         }

package/src/dataSource/dataSource.ts

@@ -1,5 +1,5 @@
-import { DataSource } from "typeorm";
-import type { DataSourceOptions } from "typeorm/data-source/DataSourceOptions";
+import { DataSource } from 'typeorm';
+import type { DataSourceOptions } from 'typeorm/data-source/DataSourceOptions';
 
 let dataSource: DataSource | undefined;
 
@@ -10,7 +10,7 @@ export async function initDataSource(options: DataSourceOptions) {
 
 export function getDataSource() {
     if (!dataSource || !dataSource.isInitialized) {
-        throw new Error("Data source is not initialized");
+        throw new Error('Data source is not initialized');
     }
 
     return dataSource;

package/src/dataSource/getRepository.ts

@@ -1,7 +1,7 @@
-import { getDataSource } from "@/dataSource/dataSource";
-import type { EntityTarget } from "typeorm/common/EntityTarget";
-import type { ObjectLiteral } from "typeorm/common/ObjectLiteral";
-import type { Repository } from "typeorm";
+import { getDataSource } from '@/dataSource/dataSource';
+import type { EntityTarget } from 'typeorm/common/EntityTarget';
+import type { ObjectLiteral } from 'typeorm/common/ObjectLiteral';
+import type { Repository } from 'typeorm';
 
 export function getRepository<Entity extends ObjectLiteral>(entity: EntityTarget<Entity>): Repository<Entity> {
     return getDataSource().getRepository<Entity>(entity);

package/src/decorators/FileColumn/FileColumn.ts

@@ -1,15 +1,15 @@
-import { getMetadataArgsStorage } from "typeorm";
-import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
-import type { FileType } from "./FileType";
+import { getMetadataArgsStorage } from 'typeorm';
+import type { ColumnMetadataArgs } from 'typeorm/metadata-args/ColumnMetadataArgs';
+import type { FileType } from './FileType';
 
-export function FileColumn(options: { saveDirectory: string, publicPath: string }) {
+export function FileColumn(options: { saveDirectory: string; publicPath: string }) {
     return function decorator(object: any, propertyName: string) {
         getMetadataArgsStorage().columns.push({
             target: object.constructor,
             propertyName,
-            mode: "regular",
+            mode: 'regular',
             options: {
-                type: "json",
+                type: 'json',
                 isFile: true,
                 nullable: true,
                 transformer: {
@@ -41,7 +41,7 @@ export function FileColumn(options: { saveDirectory: string, publicPath: string
                                 single = true;
                             }
                             for (const value of values) {
-                                if (!value.src.startsWith("data:")) {
+                                if (!value.src.startsWith('data:')) {
                                     value.src = options.publicPath + value.src;
                                 }
                             }
@@ -50,8 +50,8 @@ export function FileColumn(options: { saveDirectory: string, publicPath: string
                             }
                         }
                         return values;
-                    }
-                }
+                    },
+                },
             },
         } as ColumnMetadataArgs);
     };

package/src/decorators/FileColumn/FileTransformer.ts

@@ -1,8 +1,8 @@
-import type { FileType } from "@/decorators/FileColumn/FileType";
+import type { FileType } from '@/decorators/FileColumn/FileType';
 
 export type FileTransformer = {
-    isFile: true,
-    fileOptions: { saveDirectory: string, publicPath: string },
-    to: (value: FileType) => FileType,
-    from: (value: FileType) => FileType
-}
+    isFile: true;
+    fileOptions: { saveDirectory: string; publicPath: string };
+    to: (value: FileType) => FileType;
+    from: (value: FileType) => FileType;
+};

package/src/decorators/FileColumn/FileType.ts

@@ -1,5 +1,5 @@
 export type FileType = {
-    name: string,
-    src: string,
-    type: string,
-}
+    name: string;
+    src: string;
+    type: string;
+};

package/src/decorators/FileColumn/FileWriter.ts

@@ -2,7 +2,6 @@ import { PassThrough, Readable } from 'stream';
 import { createWriteStream, existsSync, mkdirSync } from 'fs';
 import crypto from 'crypto';
 
-
 export const FileWriter = {
     async writeToFile(src: string, saveDirectory: string) {
         const base64SearchText = ';base64,';
@@ -18,18 +17,21 @@ export const FileWriter = {
         const fileEnding = src.slice(indexSlash + 1, indexBase64SearchText);
         const data = src.slice(Math.max(0, indexBase64SearchText + base64SearchText.length));
 
-        const seed = crypto.randomBytes(20);
+        const seed = crypto.randomBytes(20) as string | NodeJS.ArrayBufferView;
         const now = new Date();
 
         // Month is 0-based. Add 1 to get 1-12
-        const name = `${now.getUTCFullYear()}-${now.getUTCMonth() + 1}-${now.getUTCDate()}-${fileType}-${crypto.createHash('sha1').update(seed).digest('hex')}.${fileEnding}`;
+        const name = `${now.getUTCFullYear()}-${now.getUTCMonth() + 1}-${now.getUTCDate()}-${fileType}-${crypto
+            .createHash('sha1')
+            .update(seed)
+            .digest('hex')}.${fileEnding}`;
 
         const dataBuffer = Buffer.from(data, 'base64');
         const inputStream = new Readable();
         const dataStream = new PassThrough();
 
         if (!existsSync(saveDirectory)) {
-            mkdirSync(saveDirectory, {recursive: true});
+            mkdirSync(saveDirectory, { recursive: true });
         }
 
         const writeStream = createWriteStream(saveDirectory + name);

package/src/migration/getCreateTableColumns.ts

@@ -1,30 +1,36 @@
 // Do not change the columns here. It is needed for migration, aka creation of the database
 export function getCreateTableColumns() {
-    return [{
-        name: 'id',
-        type: 'int',
-        isPrimary: true,
-        isGenerated: true,
-        generationStrategy: 'increment',
-        isNullable: false,
-    }, {
-        name: 'createdAt',
-        type: 'datetime(6)',
-        isNullable: false,
-        default: "CURRENT_TIMESTAMP(6)",
-    }, {
-        name: 'updatedAt',
-        type: 'datetime(6)',
-        isNullable: false,
-        default: "CURRENT_TIMESTAMP(6)",
-        onUpdate: "CURRENT_TIMESTAMP(6)",
-    }, {
-        name: 'deletedAt',
-        type: 'datetime(6)',
-        isNullable: true,
-    }, {
-        name: 'version',
-        type: 'int',
-        isNullable: false,
-    }] as const;
+    return [
+        {
+            name: 'id',
+            type: 'int',
+            isPrimary: true,
+            isGenerated: true,
+            generationStrategy: 'increment',
+            isNullable: false,
+        },
+        {
+            name: 'createdAt',
+            type: 'datetime(6)',
+            isNullable: false,
+            default: 'CURRENT_TIMESTAMP(6)',
+        },
+        {
+            name: 'updatedAt',
+            type: 'datetime(6)',
+            isNullable: false,
+            default: 'CURRENT_TIMESTAMP(6)',
+            onUpdate: 'CURRENT_TIMESTAMP(6)',
+        },
+        {
+            name: 'deletedAt',
+            type: 'datetime(6)',
+            isNullable: true,
+        },
+        {
+            name: 'version',
+            type: 'int',
+            isNullable: false,
+        },
+    ] as const;
 }

package/src/migration/getCreateTableColumnsV1.ts

@@ -1,27 +1,33 @@
 // Do not change the columns here. It is needed for migration, aka creation of the database
 export function getCreateTableColumnsV1() {
-    return [{
-        name: 'id',
-        type: 'int',
-        isPrimary: true,
-        isGenerated: true,
-        generationStrategy: 'increment',
-        isNullable: false,
-    }, {
-        name: 'createdAt',
-        type: 'datetime',
-        isNullable: false,
-    }, {
-        name: 'updatedAt',
-        type: 'datetime',
-        isNullable: false,
-    }, {
-        name: 'deletedAt',
-        type: 'datetime(6)',
-        isNullable: true,
-    }, {
-        name: 'version',
-        type: 'int',
-        isNullable: false,
-    }] as const;
+    return [
+        {
+            name: 'id',
+            type: 'int',
+            isPrimary: true,
+            isGenerated: true,
+            generationStrategy: 'increment',
+            isNullable: false,
+        },
+        {
+            name: 'createdAt',
+            type: 'datetime',
+            isNullable: false,
+        },
+        {
+            name: 'updatedAt',
+            type: 'datetime',
+            isNullable: false,
+        },
+        {
+            name: 'deletedAt',
+            type: 'datetime(6)',
+            isNullable: true,
+        },
+        {
+            name: 'version',
+            type: 'int',
+            isNullable: false,
+        },
+    ] as const;
 }

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "@ainias42/typescript-config",
+  "extends": "@ainias42/config/tsconfig.json",
   "compilerOptions": {
     "jsx": "react",
     "module": "commonjs",
@@ -23,14 +23,5 @@
   "include": [
     "src/**/*.tsx",
     "src/**/*.ts"
-  ],
-  "tsc-alias": {
-    "resolveFullPaths": true,
-    "replacers": {
-      "scssReplacer": {
-        "enabled": true,
-        "file": "../tscReplacers/scssReplacer.cjs"
-      }
-    }
-  }
+  ]
 }