@belopash/typeorm-store 0.0.0

package/src/updateMap.ts

@@ -0,0 +1,74 @@
+export enum UpdateType {
+    Insert,
+    Upsert,
+    Remove,
+}
+
+export interface Update {
+    id: string
+    type: UpdateType
+}
+
+export class UpdateMap {
+    private map: Map<string, UpdateType> = new Map()
+
+    get(id: string) {
+        return this.map.get(id)
+    }
+
+    insert(id: string) {
+        const prevType = this.map.get(id)
+
+        switch (prevType) {
+            case UpdateType.Insert:
+            case UpdateType.Upsert:
+                throw new Error(`Can not add id ${id} because it is already marked as insert or upsert`)
+            case UpdateType.Remove:
+                this.map.set(id, UpdateType.Upsert)
+                break
+            case undefined:
+                this.map.set(id, UpdateType.Insert)
+                break
+        }
+    }
+
+    upsert(id: string) {
+        const prevType = this.map.get(id)
+
+        switch (prevType) {
+            case UpdateType.Insert:
+                break
+            case UpdateType.Upsert:
+            case UpdateType.Remove:
+            case undefined:
+                this.map.set(id, UpdateType.Upsert)
+                break
+        }
+    }
+
+    remove(id: string) {
+        const prevType = this.map.get(id)
+
+        switch (prevType) {
+            case UpdateType.Insert:
+            case UpdateType.Upsert:
+            case UpdateType.Remove:
+            case undefined:
+                this.map.set(id, UpdateType.Remove)
+                break
+        }
+    }
+
+    clear() {
+        this.map.clear()
+    }
+
+    *[Symbol.iterator](): IterableIterator<Update> {
+        for (const [id, type] of this.map) {
+            yield {
+                id,
+                type,
+            }
+        }
+    }
+}

package/src/utils.ts

@@ -0,0 +1,49 @@
+export function* splitIntoBatches<T>(list: T[], maxBatchSize: number): Generator<T[]> {
+    if (list.length <= maxBatchSize) {
+        yield list
+    } else {
+        let offset = 0
+        while (list.length - offset > maxBatchSize) {
+            yield list.slice(offset, offset + maxBatchSize)
+            offset += maxBatchSize
+        }
+        yield list.slice(offset)
+    }
+}
+
+export function copy<T>(obj: T): T {
+    if (typeof obj !== 'object' || obj == null) return obj
+    else if (obj instanceof Date) {
+        return new Date(obj) as any
+    } else if (Array.isArray(obj)) {
+        return copyArray(obj) as any
+    } else if (obj instanceof Map) {
+        return new Map(copyArray(Array.from(obj))) as any
+    } else if (obj instanceof Set) {
+        return new Set(copyArray(Array.from(obj))) as any
+    } else if (ArrayBuffer.isView(obj)) {
+        return copyBuffer(obj)
+    } else {
+        const clone = Object.create(Object.getPrototypeOf(obj))
+        for (var k in obj) {
+            clone[k] = copy(obj[k])
+        }
+        return clone
+    }
+}
+
+function copyBuffer(buf: any) {
+    if (buf instanceof Buffer) {
+        return Buffer.from(buf)
+    }
+
+    return new buf.constructor(buf.buffer.slice(), buf.byteOffset, buf.length)
+}
+
+function copyArray(arr: any[]) {
+    const clone = new Array(arr.length)
+    for (let i = 0; i < arr.length; i++) {
+        clone[i] = copy(clone[i])
+    }
+    return clone
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "lib",
+    "rootDir": "src",
+    "allowJs": true,
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": [
+    "node_modules"
+  ]
+}