@punks/backend-entity-manager 0.0.443 → 0.0.445

package/dist/cjs/types/abstractions/actions.d.ts

@@ -38,10 +38,10 @@ export interface IEntitiesExportAction<TEntity, TEntitySearchParameters extends
     execute(input: EntitiesExportInput<TEntity, TEntitySearchParameters, TSorting, TCursor>): Promise<EntitiesExportResult>;
 }
 export interface IEntitiesImportAction<TEntity> {
-    execute(input: EntitiesImportInput<unknown>): Promise<EntitiesImportResult>;
+    execute<TPayload = unknown>(input: EntitiesImportInput<TPayload>): Promise<EntitiesImportResult>;
 }
 export interface IEntitiesParseAction<TEntity> {
-    execute(input: EntitiesParseInput<unknown>): Promise<EntitiesParseResult<unknown>>;
+    execute<TPayload = unknown>(input: EntitiesParseInput<TPayload>): Promise<EntitiesParseResult<unknown>>;
 }
 export interface IEntitiesSampleDownloadAction<TEntity> {
     execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;

package/dist/cjs/types/base/serializer.d.ts

@@ -19,7 +19,7 @@ export declare abstract class EntitySerializer<TEntity, TEntityId, TEntitySearch
     constructor(services: EntityServiceLocator<TEntity, TEntityId>, options?: EntitySerializerOptions | undefined);
     export(filters?: TEntitySearchParameters): Promise<TSheetItem[]>;
     import(items: TSheetItem[], payload?: TPayload): Promise<void>;
-    parse(data: Buffer, format: EntitySerializationFormat): Promise<ImportEntry<TSheetItem, TEntityId>[]>;
+    parse<TPayload>(data: Buffer, format: EntitySerializationFormat, payload?: TPayload): Promise<ImportEntry<TSheetItem, TEntityId>[]>;
     private parseCsv;
     private parseXlsx;
     private convertSheetRecord;
@@ -27,7 +27,7 @@ export declare abstract class EntitySerializer<TEntity, TEntityId, TEntitySearch
     createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
     private buildSampleFile;
     serialize(data: TSheetItem[], format: EntitySerializationFormat): Promise<EntityExportFile>;
-    protected abstract getDefinition(context: TContext): Promise<EntitySerializerSheetDefinition<TSheetItem>>;
+    protected abstract getDefinition(context: TContext, payload?: TPayload): Promise<EntitySerializerSheetDefinition<TSheetItem>>;
     protected abstract loadEntities(filters?: TEntitySearchParameters): Promise<TEntity[]>;
     protected abstract convertToSheetItems(entities: TEntity[]): Promise<TSheetItem[]>;
     protected validateSheetItem(item: TSheetItem, allItems: TSheetItem[], context: TContext): void;

package/dist/cjs/types/commands/import.d.ts

@@ -6,7 +6,7 @@ export declare class EntitiesImportCommand<TEntity> implements IEntitiesImportCo
     private readonly services;
     private readonly settings;
     constructor(services: EntityServiceLocator<TEntity, unknown>, settings: EntitiesImportExportSettings);
-    execute<TPayload = unknown>(input: EntitiesImportInput<TPayload>): Promise<EntitiesImportResult>;
+    execute<TPayload>(input: EntitiesImportInput<TPayload>): Promise<EntitiesImportResult>;
     private parseImportFile;
     private uploadImportFile;
     private buildAbsoluteBucketPath;

package/dist/esm/index.js

@@ -242,9 +242,10 @@ class EntitySerializer {
         }
         this.logger.info(`Entities import -> completed (${items.length} items)`);
     }
-    async parse(data, format) {
+    async parse(data, format, payload) {
         const context = await this.getContext();
-        const definition = await this.getDefinition(context);
+        console.log("/serializer/base/parse", payload);
+        const definition = await this.getDefinition(context, payload);
         switch (format) {
             case EntitySerializationFormat.Csv:
                 return this.parseCsv(data, definition);
@@ -950,6 +951,7 @@ class EntitiesImportCommand {
             contentType: input.file.contentType,
             fileName: input.file.fileName,
         });
+        console.log("/commands/import/execute", input?.payload);
         const importEntities = await this.parseImportFile(input.file.content, input.format, input?.payload);
         const validEntities = importEntities.filter((x) => x.status.isValid);
         const invalidEntities = importEntities.filter((x) => !x.status.isValid);
@@ -971,6 +973,7 @@ class EntitiesImportCommand {
         };
     }
     async parseImportFile(content, format, payload) {
+        console.log("/import/command/parseImportFile", payload);
         return await this.services
             .resolveSerializer()
             .parse(content, format, payload);