@punks/backend-entity-manager 0.0.91 → 0.0.93

package/dist/cjs/types/__test__/entity/foo.d.ts

@@ -67,7 +67,7 @@ export interface FooUpdateDto {
         age: number;
     };
 }
-export declare class FooSerializer extends EntitySerializer<FooEntity> {
+export declare class FooSerializer extends EntitySerializer<FooEntity, string> {
     constructor(entityName: string);
     protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
 }

package/dist/cjs/types/__test__/providers/typeorm/entity/foo.d.ts

@@ -81,7 +81,7 @@ export declare class FooConverter implements IEntityConverter<FooEntity, FooDto,
     createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
     updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
 }
-export declare class FooSerializer extends EntitySerializer<FooEntity> {
+export declare class FooSerializer extends EntitySerializer<FooEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
 }
 export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {

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

@@ -30,7 +30,7 @@ export interface IEntityManagerServiceRoot {
 export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
     getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
     mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>(input: EntitiesMapOperationsInput<TEntitiesQueryBuilder>): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addSerializer<TEntitySerializer extends IEntitySerializer<TEntity>>(serializer: TEntitySerializer): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addSerializer<TEntitySerializer extends IEntitySerializer<TEntity, TEntityId>>(serializer: TEntitySerializer): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addAdapter<TEntityCreateData, TEntityUpdateData, TEntityAdapter extends IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>>(adapter: TEntityAdapter): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addAuthorization<TEntityAuthorizationMiddleware extends IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>({ middleware, }: {

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

@@ -2,7 +2,9 @@
 import { EntitySerializationFormat } from "./serializer";
 export type EntitiesImportInput = {
     format: EntitySerializationFormat;
+    fileName: string;
     content: Buffer;
+    contentType: string;
 };
 export type EntitiesImportStatistics = {
     importedCount: number;

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

@@ -6,6 +6,7 @@ export type EntitySerializerColumnDefinition<TEntity> = {
     sampleValue?: any;
     parser?: (value: any) => any;
     converter?: (value: any, item: TEntity) => any;
+    idColumn?: boolean;
 };
 export type EntitySerializerSheetDefinition<TEntity> = {
     columns: EntitySerializerColumnDefinition<TEntity>[];
@@ -20,8 +21,12 @@ export declare enum EntitySerializationFormat {
     Json = "json",
     Xlsx = "xlsx"
 }
-export interface IEntitySerializer<TEntity> {
+export type ImportEntry<TEntity, TEntityId> = {
+    id?: TEntityId;
+    item: TEntity;
+};
+export interface IEntitySerializer<TEntity, TEntityId> {
     serialize(data: TEntity[], format: EntitySerializationFormat): Promise<EntityExportFile>;
-    parse(data: Buffer, format: EntitySerializationFormat): Promise<TEntity[]>;
+    parse(data: Buffer, format: EntitySerializationFormat): Promise<ImportEntry<TEntity, TEntityId>[]>;
     createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
 }

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

@@ -1,10 +1,14 @@
 /// <reference types="node" />
 import { EntitySerializationFormat, IEntitySerializer } from "../abstractions";
-import { EntityExportFile, EntitySerializerSheetDefinition } from "../abstractions/serializer";
-export declare abstract class EntitySerializer<TEntity> implements IEntitySerializer<TEntity> {
+import { EntityExportFile, EntitySerializerSheetDefinition, ImportEntry } from "../abstractions/serializer";
+export declare abstract class EntitySerializer<TEntity, TEntityId> implements IEntitySerializer<TEntity, TEntityId> {
     protected readonly entityName: string;
     constructor(entityName: string);
-    parse(data: Buffer, format: EntitySerializationFormat): Promise<TEntity[]>;
+    parse(data: Buffer, format: EntitySerializationFormat): Promise<ImportEntry<TEntity, TEntityId>[]>;
+    private parseCsv;
+    private parseXlsx;
+    private convertSheetRecord;
+    private parseColumnValue;
     createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
     private buildSampleFile;
     serialize(data: TEntity[], format: EntitySerializationFormat): Promise<EntityExportFile>;

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

@@ -7,4 +7,9 @@ export declare class EntitiesImportCommand<TEntity> implements IEntitiesImportCo
     private readonly settings;
     constructor(services: EntityServiceLocator<TEntity, unknown>, settings: EntitiesImportExportSettings);
     execute(input: EntitiesImportInput): Promise<EntitiesImportResult>;
+    private importEntity;
+    private parseImportFile;
+    private uploadImportFile;
+    private buildAbsoluteBucketPath;
+    private get bucket();
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appCompanies/appCompany.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppCompanyEntity } from "../../database/core/entities/appCompany.entity";
-export declare class AppCompanySerializer extends NestEntitySerializer<AppCompanyEntity> {
+export declare class AppCompanySerializer extends NestEntitySerializer<AppCompanyEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppCompanyEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appDivisions/appDivision.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppDivisionEntity } from "../../database/core/entities/appDivision.entity";
-export declare class AppDivisionSerializer extends NestEntitySerializer<AppDivisionEntity> {
+export declare class AppDivisionSerializer extends NestEntitySerializer<AppDivisionEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppDivisionEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appOrganizations/appOrganization.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppOrganizationEntity } from "../../database/core/entities/appOrganization.entity";
-export declare class AppOrganizationSerializer extends NestEntitySerializer<AppOrganizationEntity> {
+export declare class AppOrganizationSerializer extends NestEntitySerializer<AppOrganizationEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppOrganizationEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appRoles/appRole.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppRoleEntity } from "../../database/core/entities/appRole.entity";
-export declare class AppRoleSerializer extends NestEntitySerializer<AppRoleEntity> {
+export declare class AppRoleSerializer extends NestEntitySerializer<AppRoleEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppRoleEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appTenants/appTenant.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppTenantEntity } from "../../database/core/entities/appTenant.entity";
-export declare class AppTenantSerializer extends NestEntitySerializer<AppTenantEntity> {
+export declare class AppTenantSerializer extends NestEntitySerializer<AppTenantEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppTenantEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appUserGroupMembers/appUserGroupMember.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppUserGroupMemberEntity } from "../../database/core/entities/appUserGroupMember.entity";
-export declare class AppUserGroupMemberSerializer extends NestEntitySerializer<AppUserGroupMemberEntity> {
+export declare class AppUserGroupMemberSerializer extends NestEntitySerializer<AppUserGroupMemberEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppUserGroupMemberEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appUserGroups/appUserGroup.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppUserGroupEntity } from "../../database/core/entities/appUserGroup.entity";
-export declare class AppUserGroupSerializer extends NestEntitySerializer<AppUserGroupEntity> {
+export declare class AppUserGroupSerializer extends NestEntitySerializer<AppUserGroupEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppUserGroupEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appUserProfiles/appUserProfile.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppUserProfileEntity } from "../../database/core/entities/appUserProfile.entity";
-export declare class AppUserProfileSerializer extends NestEntitySerializer<AppUserProfileEntity> {
+export declare class AppUserProfileSerializer extends NestEntitySerializer<AppUserProfileEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppUserProfileEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appUserRoles/appUserRole.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppUserRoleEntity } from "../../database/core/entities/appUserRole.entity";
-export declare class AppUserRoleSerializer extends NestEntitySerializer<AppUserRoleEntity> {
+export declare class AppUserRoleSerializer extends NestEntitySerializer<AppUserRoleEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppUserRoleEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/appUsers/appUser.serializer.d.ts

@@ -1,6 +1,6 @@
 import { NestEntitySerializer } from "../../../../base";
 import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
 import { AppUserEntity } from "../../database/core/entities/appUser.entity";
-export declare class AppUserSerializer extends NestEntitySerializer<AppUserEntity> {
+export declare class AppUserSerializer extends NestEntitySerializer<AppUserEntity, string> {
     protected getDefinition(): EntitySerializerSheetDefinition<AppUserEntity>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/foos/foo.serializer.d.ts

@@ -1,6 +1,6 @@
 import { EntityManagerRegistry, EntitySerializerSheetDefinition, NestEntitySerializer } from "../../../../../..";
 import { FooEntity } from "../../database/core/entities/foo.entity";
-export declare class FooSerializer extends NestEntitySerializer<FooEntity> {
+export declare class FooSerializer extends NestEntitySerializer<FooEntity, string> {
     constructor(registry: EntityManagerRegistry);
     protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
 }

package/dist/cjs/types/platforms/nest/base/entityActions.d.ts

@@ -3,7 +3,7 @@ import { IEntitiesDeleteParameters } from "../../../abstractions/commands";
 import { EntityServiceLocator } from "../../../providers/services";
 import { EntityManagerRegistry } from "../ioc";
 export declare abstract class NestEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
+    protected readonly services: EntityServiceLocator<TEntity, unknown>;
     private actionsInstance;
     constructor(entityName: string, registry: EntityManagerRegistry);
     get manager(): IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets>;

package/dist/cjs/types/platforms/nest/base/entityManager.d.ts

@@ -3,7 +3,7 @@ import { IEntitiesDeleteParameters } from "../../../abstractions/commands";
 import { EntityServiceLocator } from "../../../providers/services";
 import { EntityManagerRegistry } from "../ioc/registry";
 export declare abstract class NestEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
+    protected readonly services: EntityServiceLocator<TEntity, unknown>;
     private managerInstance;
     constructor(entityName: string, registry: EntityManagerRegistry);
     get manager(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets>;

package/dist/cjs/types/platforms/nest/base/entitySerializer.d.ts

@@ -1,7 +1,7 @@
 import { EntitySerializer } from "../../../base/serializer";
 import { EntityServiceLocator } from "../../../providers/services";
 import { EntityManagerRegistry } from "../ioc";
-export declare abstract class NestEntitySerializer<TEntity> extends EntitySerializer<TEntity> {
+export declare abstract class NestEntitySerializer<TEntity, TEntityId> extends EntitySerializer<TEntity, TEntityId> {
     protected readonly services: EntityServiceLocator<TEntity, unknown>;
     constructor(entityName: string, registry: EntityManagerRegistry);
 }

package/dist/cjs/types/providers/services.d.ts

@@ -31,7 +31,7 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveConnectorDeleteManager<TEntityId>(): IEntityConnectorDeleteManager<TEntity, TEntityId>;
     resolveConnectorsConfiguration(): IConnectorsConfiguration<TEntity>;
     resolveConverter<TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(): IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
-    resolveSerializer(): IEntitySerializer<TEntity>;
+    resolveSerializer(): IEntitySerializer<TEntity, TEntityId>;
     resolveAdapter<TEntityCreateData, TEntityUpdateData>(): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
     resolveAuthorizationMiddleware<TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
     resolveGetQuery<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
@@ -103,8 +103,8 @@ export declare class EntitiesServiceLocator {
     resolveAdapter<TEntity, TEntityCreateData, TEntityUpdateData>(entityName: string): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
     registerConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(entityName: string, instance: IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>): void;
     resolveConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(entityName: string): IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
-    registerSerializer<TEntity>(entityName: string, instance: IEntitySerializer<TEntity>): void;
-    resolveSerializer<TEntity>(entityName: string): IEntitySerializer<TEntity>;
+    registerSerializer<TEntity, TEntityId>(entityName: string, instance: IEntitySerializer<TEntity, TEntityId>): void;
+    resolveSerializer<TEntity, TEntityId>(entityName: string): IEntitySerializer<TEntity, TEntityId>;
     resolveAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
     registerAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>): void;
     resolveGetQuery<TEntity, TEntityId>(entityName: string): IEntityGetQuery<TEntity, TEntityId>;

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { Log, excelBuild, csvBuild, isNullOrUndefined, sort, byField, toDict, newUuid as newUuid$1, ensureTailingSlash, removeUndefinedProps } from '@punks/backend-core';
+import { Log, csvParse, excelParse, excelBuild, csvBuild, isNullOrUndefined, sort, byField, toDict, newUuid as newUuid$1, ensureTailingSlash, removeUndefinedProps } from '@punks/backend-core';
 import { applyDecorators, Injectable, SetMetadata, Global, Module, Scope, Logger, StreamableFile, HttpException, HttpStatus } from '@nestjs/common';
 import { ApiProperty } from '@nestjs/swagger';
 import { Reflector } from '@nestjs/core';
@@ -120,12 +120,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 EntitySerializationFormat.Csv:
+                return this.parseCsv(data);
+            case EntitySerializationFormat.Xlsx:
+                return this.parseXlsx(data);
+            default:
+                throw new Error(`Format ${format} not supported`);
+        }
+    }
+    parseCsv(data) {
+        const records = csvParse(data, DEFAULT_DELIMITER);
+        return records.map((x) => this.convertSheetRecord(x));
+    }
+    parseXlsx(data) {
+        const records = 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);
@@ -149,7 +184,9 @@ class EntitySerializer {
                             name: c.name,
                             value: () => c.sampleValue ?? "",
                         })),
-                    ]), "utf-8"),
+                    ], {
+                        delimiter: DEFAULT_DELIMITER,
+                    }), "utf-8"),
                 };
             case EntitySerializationFormat.Xlsx:
                 return {
@@ -188,10 +225,18 @@ class EntitySerializer {
                 return {
                     fileName,
                     contentType: "text/csv",
-                    content: Buffer.from(csvBuild(data, this.getDefinition().columns.map((c) => ({
-                        name: c.name,
-                        value: (item) => this.getColumnValue(item, c),
-                    }))), "utf-8"),
+                    content: Buffer.from(csvBuild(data, [
+                        {
+                            name: "_type",
+                            value: () => this.entityName,
+                        },
+                        ...this.getDefinition().columns.map((c) => ({
+                            name: c.name,
+                            value: (item) => this.getColumnValue(item, c),
+                        })),
+                    ], {
+                        delimiter: DEFAULT_DELIMITER,
+                    }), "utf-8"),
                 };
             case EntitySerializationFormat.Xlsx:
                 return {
@@ -200,11 +245,17 @@ class EntitySerializer {
                     content: Buffer.from(excelBuild({
                         data,
                         sheetName: this.entityName,
-                        columns: this.getDefinition().columns.map((c) => ({
-                            header: c.name,
-                            value: (item) => this.getColumnValue(item, c),
-                            headerSize: c.colSpan,
-                        })),
+                        columns: [
+                            {
+                                header: "_type",
+                                value: () => this.entityName,
+                            },
+                            ...this.getDefinition().columns.map((c) => ({
+                                header: c.name,
+                                value: (item) => this.getColumnValue(item, c),
+                                headerSize: c.colSpan,
+                            })),
+                        ],
                     })),
                 };
             case EntitySerializationFormat.Json:
@@ -943,8 +994,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.content,
+            contentType: input.contentType,
+            fileName: input.fileName,
+        });
+        const importEntities = await this.parseImportFile(input.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();
     }
 }