@punks/backend-entity-manager 0.0.356 → 0.0.358

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export interface IEmailTemplateMiddleware {
     processPayload(payload: unknown): Promise<unknown>;
 }
@@ -9,6 +10,13 @@ export interface IEmailTemplatesCollection {
     registerTemplate(id: string, template: IEmailTemplate<unknown, unknown, unknown>): void;
     getTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload>(id: string): IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>;
 }
+export type EmailAttachmentData = {
+    content: string | Buffer;
+    filename: string;
+    type?: string;
+    disposition?: string;
+    contentId?: string;
+};
 export type TemplatedEmailInput<TPayload> = {
     from?: string;
     to?: string[];
@@ -18,6 +26,7 @@ export type TemplatedEmailInput<TPayload> = {
     templateId: string;
     languageCode: string;
     payload: TPayload;
+    attachments?: EmailAttachmentData[];
 };
 export interface HtmlEmailInput<TPayload> {
     replyTo?: string;
@@ -28,6 +37,7 @@ export interface HtmlEmailInput<TPayload> {
     subjectTemplate: string;
     bodyTemplate: string;
     payload: TPayload;
+    attachments?: EmailAttachmentData[];
 }
 export interface IEmailProvider<TTemplateData> {
     sendTemplatedEmail<TPayload, TAugmentedPayload>(input: TemplatedEmailInput<TPayload>, template: IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>): Promise<void>;

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

@@ -1,6 +1,17 @@
 /// <reference types="node" />
+export type EntryValidationError = {
+    errorCode: string;
+};
+export type EntryValidationResult = {
+    isValid: boolean;
+    validationErrors: EntryValidationError[];
+};
 export type ImportEntryValidationError = {
     errorCode: string;
+    column: {
+        name: string;
+        key: string;
+    };
 };
 export type ImportEntryValidationResult = {
     isValid: boolean;
@@ -11,11 +22,12 @@ export type EntitySerializerColumnParseAction<TSheetItem> = (value: any, item: T
 export type EntitySerializerColumnConverter<TSheetItem> = (value: any, item: TSheetItem) => any;
 export type EntitySerializerColumnValidator<TSheetItem> = {
     key: string;
-    fn: (item: TSheetItem) => ImportEntryValidationResult;
+    fn: (item: TSheetItem) => EntryValidationResult;
 };
 export type EntitySerializerColumnDefinition<TSheetItem> = {
     name: string;
-    selector: keyof TSheetItem;
+    key: string;
+    selector: keyof TSheetItem | ((item: TSheetItem) => any);
     colSpan?: number;
     sampleValue?: any;
     parser?: EntitySerializerColumnParser;

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

@@ -31,5 +31,6 @@ export declare abstract class EntitySerializer<TEntity, TEntityId, TEntitySearch
     protected getContext(): Promise<TContext>;
     private buildExportFile;
     private getColumnValue;
+    private selectColumnValue;
     private buildExportFileName;
 }

package/dist/cjs/types/platforms/nest/models/parsing.d.ts

@@ -1,5 +1,10 @@
+export declare class EntityParseValidationColumn {
+    name: string;
+    key: string;
+}
 export declare class EntityParseValidationError {
     errorCode: string;
+    column: EntityParseValidationColumn;
 }
 export declare class EntityParseStatus {
     isValid: boolean;

package/dist/cjs/types/utils/validators.d.ts

@@ -1,2 +1,2 @@
-import { ImportEntryValidationResult } from "../abstractions/serializer";
-export declare const fieldRequiredValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => any) => ImportEntryValidationResult;
+import { EntryValidationResult } from "../abstractions/serializer";
+export declare const fieldRequiredValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => any) => EntryValidationResult;

package/dist/esm/index.js

@@ -227,10 +227,12 @@ class EntitySerializer {
         for (const column of definition.columns) {
             if (column.parseAction) {
                 column.parseAction(record[column.name], entity);
+                continue;
             }
-            else {
-                entity[column.selector] = this.parseColumnValue(record, column);
+            if (typeof column.selector === "function") {
+                throw new Error("Function selectors are not supported with parseAction specified");
             }
+            entity[column.selector] = this.parseColumnValue(record, column);
         }
         const validationErrors = [];
         for (const column of definition.columns) {
@@ -239,13 +241,19 @@ class EntitySerializer {
                 if (!result.isValid) {
                     validationErrors.push({
                         errorCode: validator.key,
+                        column: {
+                            name: column.name,
+                            key: column.key,
+                        },
                     });
                 }
             }
         }
         const idField = definition.columns.find((x) => x.idColumn || x.selector === "id");
         return {
-            id: idField ? entity[idField.selector] : undefined,
+            id: idField
+                ? this.selectColumnValue(entity, idField.selector)
+                : undefined,
             item: entity,
             rowIndex,
             status: {
@@ -385,11 +393,14 @@ class EntitySerializer {
         }
     }
     getColumnValue(item, definition) {
-        const rawValue = item[definition.selector];
+        const rawValue = this.selectColumnValue(item, definition.selector);
         return definition.converter
             ? definition.converter(rawValue, item)
             : rawValue;
     }
+    selectColumnValue(item, selector) {
+        return typeof selector === "function" ? selector(item) : item[selector];
+    }
     buildExportFileName(input) {
         return `${input.refDate.toISOString().replaceAll(":", "_")}_${this.entityName}.${input.format}`;
     }
@@ -34831,12 +34842,26 @@ class AppExceptionsFilterBase {
     }
 }
 
+class EntityParseValidationColumn {
+}
+__decorate([
+    ApiProperty(),
+    __metadata("design:type", String)
+], EntityParseValidationColumn.prototype, "name", void 0);
+__decorate([
+    ApiProperty(),
+    __metadata("design:type", String)
+], EntityParseValidationColumn.prototype, "key", void 0);
 class EntityParseValidationError {
 }
 __decorate([
     ApiProperty(),
     __metadata("design:type", String)
 ], EntityParseValidationError.prototype, "errorCode", void 0);
+__decorate([
+    ApiProperty(),
+    __metadata("design:type", EntityParseValidationColumn)
+], EntityParseValidationError.prototype, "column", void 0);
 class EntityParseStatus {
 }
 __decorate([
@@ -40360,6 +40385,7 @@ let AwsSesEmailProvider = class AwsSesEmailProvider {
             bcc: input.bcc ?? templateData.bcc,
             cc: input.cc ?? templateData.cc,
             from: input.from ?? templateData.from,
+            attachments: input.attachments,
         });
     }
     async sendHtmlEmail(input) {
@@ -40486,6 +40512,12 @@ let SendgridEmailProvider = class SendgridEmailProvider {
                 ...processedPayload,
             },
             templateId: templateData.sendgridTemplateId,
+            attachments: input.attachments?.map((attachment) => ({
+                ...attachment,
+                content: attachment.content instanceof Buffer
+                    ? attachment.content.toString("utf-8")
+                    : attachment.content,
+            })),
         });
         if (sendgridSettings.value.loggingEnabled) {
             this.logger.info("Sending templated email", {