@ainias42/typeorm-helper 0.0.1

package/.ctirc

@@ -0,0 +1,112 @@
+{
+  // Stream of cli spinner, you can pass stdout or stderr
+  //
+  // @mode all
+  // @default stdout
+  "spinnerStream": "stdout",
+  // Stream of cli progress, you can pass stdout or stderr
+  //
+  // @mode all
+  // @default stdout
+  "progressStream": "stdout",
+  // Stream of cli reasoner. Reasoner show name conflict error and already exist index.ts file error.
+  // You can pass stdout or stderr
+  //
+  // @mode all
+  // @default stderr
+  "reasonerStream": "stderr",
+  "options": [
+    {
+      // build mode
+      // - create: create an `index.ts` file in each directory
+      // - bundle: bundle all export information in one `index.ts` file
+      "mode": "bundle",
+      // tsconfig.json path: you must pass path with filename, like this "./tsconfig.json"
+      // only work root directory or cli parameter
+      //
+      // @mode all
+      "project": "tsconfig.json",
+      // Export filename, if you not pass this field that use "index.ts" or "index.d.ts"
+      //
+      // @mode create, bundle, remove
+      // @default index.ts
+      "exportFilename": "index.ts",
+      // add ctix comment at first line of creted index.ts file, that remark created from ctix
+      //
+      // @mode create, bundle
+      // @default false
+      "useSemicolon": true,
+      // add ctix comment at first line of creted index.ts file, that remark created from ctix
+      //
+      // @mode create, bundle
+      // @default false
+      "useBanner": false,
+      // If specified as true, adds the created date to the top of the `index.ts` file,
+      // this option only works if the `useBanner` option is enabled
+      //
+      // @mode create, bundle
+      // @default false
+      "useTimestamp": false,
+      // quote mark " or '
+      // @mode create, bundle
+      //
+      // @default '
+      "quote": "'",
+      // Use to add a literal like `"use strict"` to the top. It will be added before the banner.
+      //
+      // @mode create, bundle
+      "directive": "",
+      // keep file extension in export statement path
+      //
+      // if this option set true that see below
+      // export * from './test.ts'
+      //
+      // @mode create, bundle
+      // @default none
+      "fileExt": "none",
+      // overwrite each index.ts file
+      // @mode create, bundle
+      // @default false
+      "overwrite": true,
+      // Create a backup file if the `index.ts` file already exists.
+      // This option only works if the `overwrite` option is enabled.
+      //
+      // @mode create, bundle
+      // @default true
+      "backup": false,
+      // When generating the `index.ts` file, decide how you want to generate it
+      //
+      // @mode create, bundle
+      // @default auto
+      "generationStyle": "auto",
+      // A list of files to use when generating the index.ts file. If no value is set,
+      // the value of the include setting set in the tsconfig.json file will be used
+      //
+      // @mode create, bundle
+      "include": [
+        "src/**/*.tsx",
+        "src/**/*.ts"
+      ],
+      // A list of files to exclude when generating the index.ts file. If no value is set,
+      // the value of the exclude setting set in the tsconfig.json file is used
+      //
+      // @mode create, bundle
+      "exclude": [
+        "../../node_modules",
+        "dist/**/*",
+        "dist/src/**/*"
+      ],
+      // Output directory. Default value is same project directory
+      // @mode bundle
+      "output": "./src",
+      // remove with backup file
+      // @mode remove
+      // @default false
+      "removeBackup": false,
+      // answer `yes` to all questions
+      // @mode remove
+      // @default false
+      "forceYes": false
+    }
+  ]
+}

package/.eslintrc.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+    extends: ['@ainias42/eslint-config'].map(require.resolve),
+};

package/.prettierrc

@@ -0,0 +1 @@
+"@ainia42/prettier-config"

package/bin/release.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+../../bin/release.sh $1 typeorm-helper

package/bin/updateCopies.js

@@ -0,0 +1,87 @@
+import path from "path";
+import {exec} from "child_process";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageName = JSON.parse(fs.readFileSync(__dirname+"/../package.json", {encoding: "utf8"})).name;
+
+let pathsToProjects = [
+    // '/home/silas/Projekte/web/dnd',
+    // '/home/silas/Projekte/web/smd-mail',
+    // '/home/silas/Projekte/web/games',
+    // '/home/silas/Projekte/web/react-windows',
+    // '/home/silas/Projekte/web/cordova-sites',
+    "/Users/sguenter/Projekte/Privat/dnd",
+
+];
+
+const deleteFolderRecursive = function (path) {
+    if (fs.existsSync(path)) {
+        fs.readdirSync(path).forEach(function (file) {
+            let curPath = path + '/' + file;
+            if (fs.lstatSync(curPath).isDirectory()) {
+                // recurse
+                deleteFolderRecursive(curPath);
+            } else {
+                // delete file
+                fs.unlinkSync(curPath);
+            }
+        });
+        fs.rmdirSync(path);
+    }
+};
+
+async function execPromise(command) {
+    return new Promise((resolve, reject) => {
+        console.log('executing ' + command + '...');
+        exec(command, (err, stdout, stderr) => {
+            console.log(stdout);
+            console.log(stderr);
+            if (err) {
+                reject([err, stdout, stderr]);
+            } else {
+                resolve([stdout, stderr]);
+            }
+        });
+    });
+}
+
+execPromise('npm pack')
+    .then(async (std) => {
+        let thisPath = process.cwd();
+        let name = std[0].trim();
+        let pathToTar = path.resolve(thisPath, name);
+
+        if (!fs.existsSync('tmp')) {
+            fs.mkdirSync('tmp');
+        }
+        process.chdir('tmp');
+        await execPromise('tar -xvzf ' + pathToTar + ' -C ./');
+        process.chdir('package');
+        // fs.unlinkSync('package.json');
+
+        let promise = Promise.resolve();
+        pathsToProjects.forEach((project) => {
+            promise = promise.then(async () => {
+                let resultDir = path.resolve(project, 'node_modules', packageName);
+                console.log(resultDir, fs.existsSync(resultDir));
+                if (!fs.existsSync(resultDir)) {
+                    fs.mkdirSync(resultDir);
+                }
+                return execPromise('cp -r ./* ' + resultDir);
+            });
+        });
+        await promise;
+
+        process.chdir(thisPath);
+        fs.unlinkSync(name);
+        deleteFolderRecursive('tmp');
+        // fs.unlinkSync("tmp");
+
+        console.log('done!');
+    })
+    .catch((e) => {
+        console.error(e);
+    });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ainias42/typeorm-helper",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "ctix build && tsc && tsc-alias",
+    "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "gitea@git.silas.link:Ainias/libraries.git"
+  },
+  "dependencies": {
+    "@ainias42/js-helper": ">=0.8.15",
+    "typeorm": "^0.3.20",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "ctix": "^2.6.4",
+    "prettier": "^3.3.3"
+  }
+}

package/src/BaseModel.ts

@@ -0,0 +1,24 @@
+import {
+    CreateDateColumn,
+    DeleteDateColumn,
+    PrimaryGeneratedColumn,
+    UpdateDateColumn,
+    VersionColumn
+} from "typeorm";
+
+export class BaseModel {
+    @PrimaryGeneratedColumn()
+    id?: number;
+
+    @CreateDateColumn()
+    createdAt?: Date;
+
+    @UpdateDateColumn()
+    updatedAt?: Date;
+
+    @DeleteDateColumn()
+    deletedAt?: Date;
+
+    @VersionColumn()
+    version?: number;
+}

package/src/DbNamingStrategy.ts

@@ -0,0 +1,63 @@
+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){
+            key += `_${suffix}`;
+        }
+        return key;
+    }
+
+    indexName(tableOrName: Table | string, columnNames: string[], where?: string): string {
+        return this.createKey("IDX", tableOrName, columnNames, where);
+    }
+
+    foreignKeyName(
+        tableOrName: Table | string,
+        columnNames: string[],
+    ): string {
+        return this.createKey("FK", tableOrName, columnNames);
+    }
+
+    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);
+    }
+
+    primaryKeyName(tableOrName: Table | string, columnNames: string[]): string {
+        return this.createKey("PK", tableOrName, columnNames);
+    }
+
+    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);
+    }
+
+    exclusionConstraintName(
+        tableOrName: Table | string,
+        expression: string,
+    ): string {
+        return this.createKey("XCL", tableOrName, [expression]);
+    }
+}

package/src/ServerSubscriber.ts

@@ -0,0 +1,95 @@
+/* eslint-disable class-methods-use-this */
+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";
+
+@EventSubscriber()
+export class ServerSubscriber implements EntitySubscriberInterface {
+
+    async saveFiles(entity: ObjectLiteral, columns: ColumnMetadata[]) {
+        const promises = [];
+        for (const column of columns) {
+            const transformer = column.transformer as FileTransformer | undefined;
+            if (transformer?.isFile) {
+                let values: FileType | FileType[] | undefined = Reflect.get(entity, column.propertyName);
+                if (values) {
+                    let single = false;
+                    if (!Array.isArray(values)) {
+                        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);
+                        }
+                    }));
+                }
+            }
+        }
+        await Promise.all(promises);
+    }
+
+    /**
+     * Called before post insertion.
+     */
+    async beforeInsert({entity, metadata: {columns}}: InsertEvent<any>) {
+        if (entity) {
+            // TODO check if this is necessary
+            // Reflect.set(entity, "updatedAt", new Date());
+            // Reflect.set(entity, "createdAt", new Date());
+
+            await this.saveFiles(entity, columns);
+        }
+    }
+
+    /**
+     * Called before entity update.
+     */
+    async beforeUpdate(event: UpdateEvent<any>) {
+        // To know if an entity has a version number, we check if versionColumn
+        // 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
+            );
+
+            // Getting the entity's version from the database
+            const versionFromDatabase = event.databaseEntity[event.metadata.versionColumn.propertyName];
+
+            // they should match otherwise someone has changed it underneath us
+            if (versionFromDatabase !== versionFromUpdate) {
+                throw new OptimisticLockVersionMismatchError(
+                    event.metadata.name,
+                    versionFromDatabase,
+                    versionFromUpdate
+                );
+            }
+        }
+
+        if (event.entity) {
+            Reflect.set(event.entity, "updatedAt", new Date());
+        }
+
+        const {columns} = event.metadata;
+        const {entity} = event;
+        if (entity) {
+            await this.saveFiles(entity, columns);
+        }
+    }
+
+    // beforeRemove({metadata, entity, ...other}: RemoveEvent<any>): Promise<any> | void {
+        // TODO Remove files from server (?)
+    // }
+}

package/src/dataSource.ts

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

package/src/decorators/FileColumn/FileColumn.ts

@@ -0,0 +1,58 @@
+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 }) {
+    return function decorator(object: any, propertyName: string) {
+        getMetadataArgsStorage().columns.push({
+            target: object.constructor,
+            propertyName,
+            mode: "regular",
+            options: {
+                type: "json",
+                isFile: true,
+                nullable: true,
+                transformer: {
+                    isFile: true,
+                    fileOptions: options,
+                    to: (values: FileType | FileType[] | undefined) => {
+                        if (values) {
+                            let single = false;
+                            if (!Array.isArray(values)) {
+                                values = [values];
+                                single = true;
+                            }
+                            for (const value of values) {
+                                if (value.src.startsWith(options.publicPath)) {
+                                    value.src = value.src.slice(options.publicPath.length);
+                                }
+                            }
+                            if (single) {
+                                return values[0];
+                            }
+                        }
+                        return values;
+                    },
+                    from: (values: FileType | FileType[] | undefined) => {
+                        if (values) {
+                            let single = false;
+                            if (!Array.isArray(values)) {
+                                values = [values];
+                                single = true;
+                            }
+                            for (const value of values) {
+                                if (!value.src.startsWith("data:")) {
+                                    value.src = options.publicPath + value.src;
+                                }
+                            }
+                            if (single) {
+                                return values[0];
+                            }
+                        }
+                        return values;
+                    }
+                }
+            },
+        } as ColumnMetadataArgs);
+    };
+}

package/src/decorators/FileColumn/FileTransformer.ts

@@ -0,0 +1,8 @@
+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
+}

package/src/decorators/FileColumn/FileType.ts

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

package/src/decorators/FileColumn/FileWriter.ts

@@ -0,0 +1,47 @@
+import { PassThrough, Readable } from 'stream';
+import { createHash, randomBytes } from 'crypto';
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+
+
+export const FileWriter = {
+    async writeToFile(src: string, saveDirectory: string) {
+        const base64SearchText = ';base64,';
+        const indexBase64SearchText = src.indexOf(base64SearchText);
+        const indexSlash = src.indexOf('/');
+
+        // file is already a url
+        if (indexBase64SearchText === -1 || indexSlash === -1 || !src.startsWith('data:')) {
+            return src;
+        }
+
+        const fileType = src.slice('data:'.length, indexSlash);
+        const fileEnding = src.slice(indexSlash + 1, indexBase64SearchText);
+        const data = src.slice(Math.max(0, indexBase64SearchText + base64SearchText.length));
+
+        const seed = randomBytes(20);
+        const now = new Date();
+
+        // Month is 0-based. Add 1 to get 1-12
+        const name = `${now.getUTCFullYear()}-${now.getUTCMonth()+1}-${now.getUTCDate()}-${fileType}-${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});
+        }
+
+        const writeStream = createWriteStream(saveDirectory + name);
+        inputStream.pipe(dataStream);
+
+        inputStream.push(dataBuffer);
+        // eslint-disable-next-line unicorn/no-array-push-push
+        inputStream.push(null);
+
+        const resultPromise = new Promise((r) => writeStream.addListener('finish', r));
+        dataStream.pipe(writeStream);
+        await resultPromise;
+        return name;
+    },
+};

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './BaseModel';
+export * from './dataSource';
+export * from './DbNamingStrategy';
+export * from './ServerSubscriber';
+export * from './migration/getCreateTableColumns';
+export * from './decorators/FileColumn/FileColumn';
+export * from './decorators/FileColumn/FileTransformer';
+export * from './decorators/FileColumn/FileType';
+export * from './decorators/FileColumn/FileWriter';

package/src/migration/getCreateTableColumns.ts

@@ -0,0 +1,27 @@
+// 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',
+        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

@@ -0,0 +1,35 @@
+{
+  "extends": "@ainias42/typescript-config",
+  "compilerOptions": {
+    "jsx": "react",
+    "outDir": "./dist",
+    "declaration": true,
+    "baseUrl": "./",
+    "paths": {
+      "@/*": [
+        "src/*"
+      ],
+      "@cli/*": [
+        "cli/*"
+      ]
+    }
+  },
+  "exclude": [
+    "../../node_modules",
+    "dist/**/*",
+    "dist/src/**/*"
+  ],
+  "include": [
+    "src/**/*.tsx",
+    "src/**/*.ts",
+  ],
+  "tsc-alias": {
+    "resolveFullPaths": true,
+    "replacers": {
+      "scssReplacer": {
+        "enabled": true,
+        "file": "../tscReplacers/scssReplacer.cjs"
+      }
+    }
+  }
+}