@punks/backend-entity-manager 0.0.92 → 0.0.94

package/dist/cjs/index.js

@@ -128,12 +128,47 @@ class EntitySeeder {
     }
 }
 
+const DEFAULT_DELIMITER = ";";
 class EntitySerializer {
     constructor(entityName) {
         this.entityName = entityName;
     }
     async parse(data, format) {
-        throw new Error("Method not implemented.");
+        switch (format) {
+            case exports.EntitySerializationFormat.Csv:
+                return this.parseCsv(data);
+            case exports.EntitySerializationFormat.Xlsx:
+                return this.parseXlsx(data);
+            default:
+                throw new Error(`Format ${format} not supported`);
+        }
+    }
+    parseCsv(data) {
+        const records = backendCore.csvParse(data, DEFAULT_DELIMITER);
+        return records.map((x) => this.convertSheetRecord(x));
+    }
+    parseXlsx(data) {
+        const records = backendCore.excelParse(data);
+        return records.map((x) => this.convertSheetRecord(x));
+    }
+    convertSheetRecord(record) {
+        if (!record._type || record._type !== this.entityName) {
+            throw new Error(`Invalid record type ${record._type}`);
+        }
+        const definition = this.getDefinition();
+        const entity = {};
+        for (const column of definition.columns) {
+            entity[column.selector] = this.parseColumnValue(record, column);
+        }
+        const idField = definition.columns.find((x) => x.idColumn || x.selector === "id");
+        return {
+            id: idField ? entity[idField.selector] : undefined,
+            item: entity,
+        };
+    }
+    parseColumnValue(row, definition) {
+        const rawValue = row[definition.name];
+        return definition.parser ? definition.parser(rawValue) : rawValue;
     }
     async createSample(format) {
         return await this.buildSampleFile(format);
@@ -157,7 +192,9 @@ class EntitySerializer {
                             name: c.name,
                             value: () => c.sampleValue ?? "",
                         })),
-                    ]), "utf-8"),
+                    ], {
+                        delimiter: DEFAULT_DELIMITER,
+                    }), "utf-8"),
                 };
             case exports.EntitySerializationFormat.Xlsx:
                 return {
@@ -205,7 +242,9 @@ class EntitySerializer {
                             name: c.name,
                             value: (item) => this.getColumnValue(item, c),
                         })),
-                    ]), "utf-8"),
+                    ], {
+                        delimiter: DEFAULT_DELIMITER,
+                    }), "utf-8"),
                 };
             case exports.EntitySerializationFormat.Xlsx:
                 return {
@@ -963,8 +1002,52 @@ class EntitiesImportCommand {
         this.services = services;
         this.settings = settings;
     }
-    execute(input) {
-        throw new Error("Method not implemented.");
+    async execute(input) {
+        await this.uploadImportFile({
+            content: input.file.content,
+            contentType: input.file.contentType,
+            fileName: input.file.fileName,
+        });
+        const importEntities = await this.parseImportFile(input.file.content, input.format);
+        for (const entry of importEntities) {
+            await this.importEntity(entry);
+        }
+        return {
+            statistics: {
+                importedCount: importEntities.length,
+                createdCount: 0,
+                unchangedCount: 0,
+                updatedCount: 0,
+            },
+        };
+    }
+    async importEntity(entry) {
+        try {
+            if (!entry.id) {
+                return this.services.resolveCreateCommand().execute(entry.item);
+            }
+            return this.services.resolveUpsertCommand().execute(entry.id, entry.item);
+        }
+        catch (error) {
+            throw new Error(`Error importing entry with id ${entry.id}`);
+        }
+    }
+    async parseImportFile(content, format) {
+        return await this.services.resolveSerializer().parse(content, format);
+    }
+    async uploadImportFile(file) {
+        await this.bucket.fileUpload({
+            bucket: this.settings.exportBucket.bucket,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+            content: file.content,
+            contentType: file.contentType,
+        });
+    }
+    buildAbsoluteBucketPath(relativePath) {
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/imports/${createDayPath(new Date())}/${relativePath}`;
+    }
+    get bucket() {
+        return this.services.getRootServices().resolveBucketProvider();
     }
 }