@hed-hog/contact 0.0.304 → 0.0.305

package/dist/person/person.service.js

@@ -21,6 +21,7 @@ const core_1 = require("@hed-hog/core");
 const common_1 = require("@nestjs/common");
 const account_dto_1 = require("./dto/account.dto");
 const create_interaction_dto_1 = require("./dto/create-interaction.dto");
+const import_dto_1 = require("./dto/import.dto");
 const CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING = 'contact-allow-company-registration';
 const CONTACT_OWNER_ROLE_SLUG = 'owner-contact';
 const CONTACT_OWNER_ALLOWED_ROLE_SLUGS = [
@@ -655,7 +656,22 @@ let PersonService = PersonService_1 = class PersonService {
                 person_metadata: {
                     some: {
                         key: OWNER_USER_METADATA_KEY,
-                        value: ownerUserId,
+                        value: {
+                            equals: ownerUserId,
+                        },
+                    },
+                },
+            });
+        }
+        const employerCompanyId = this.coerceNumber(paginationParams.employer_company_id);
+        if (employerCompanyId > 0) {
+            metadataFilters.push({
+                person_metadata: {
+                    some: {
+                        key: EMPLOYER_COMPANY_METADATA_KEY,
+                        value: {
+                            equals: employerCompanyId,
+                        },
                     },
                 },
             });
@@ -665,7 +681,9 @@ let PersonService = PersonService_1 = class PersonService {
                 person_metadata: {
                     some: {
                         key: SOURCE_METADATA_KEY,
-                        value: paginationParams.source,
+                        value: {
+                            equals: paginationParams.source,
+                        },
                     },
                 },
             });
@@ -676,7 +694,9 @@ let PersonService = PersonService_1 = class PersonService {
                 person_metadata: {
                     some: {
                         key: LIFECYCLE_STAGE_METADATA_KEY,
-                        value: paginationParams.lifecycle_stage,
+                        value: {
+                            equals: paginationParams.lifecycle_stage,
+                        },
                     },
                 },
             });
@@ -824,8 +844,7 @@ let PersonService = PersonService_1 = class PersonService {
             await this.syncPersonMetadata(tx, person.id, {
                 owner_user_id: data.owner_user_id,
             });
-            await this.upsertPrimaryAccountContact(tx, person.id, 'EMAIL', data.email);
-            await this.upsertPrimaryAccountContact(tx, person.id, 'PHONE', data.phone);
+            await this.syncAccountArrays(tx, person.id, data, locale);
             return {
                 success: true,
                 id: person.id,
@@ -855,8 +874,7 @@ let PersonService = PersonService_1 = class PersonService {
             await this.syncPersonMetadata(tx, id, {
                 owner_user_id: data.owner_user_id,
             });
-            await this.upsertPrimaryAccountContact(tx, id, 'EMAIL', data.email);
-            await this.upsertPrimaryAccountContact(tx, id, 'PHONE', data.phone);
+            await this.syncAccountArrays(tx, id, data, locale);
             return {
                 success: true,
                 id,
@@ -2071,15 +2089,29 @@ let PersonService = PersonService_1 = class PersonService {
         if (fromStage === toStage) {
             return;
         }
-        await client.crm_stage_history.create({
-            data: {
-                person_id: personId,
-                from_stage: fromStage !== null && fromStage !== void 0 ? fromStage : null,
-                to_stage: toStage,
-                changed_by_user_id: changedByUserId,
-                changed_at: new Date(),
-            },
-        });
+        const fromStageSql = fromStage
+            ? api_prisma_1.Prisma.sql `CAST(${fromStage} AS crm_stage_history_from_stage_f4181e9874_enum)`
+            : api_prisma_1.Prisma.sql `NULL`;
+        await client.$executeRaw(api_prisma_1.Prisma.sql `
+        INSERT INTO crm_stage_history (
+          person_id,
+          from_stage,
+          to_stage,
+          changed_by_user_id,
+          changed_at,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${personId},
+          ${fromStageSql},
+          CAST(${toStage} AS crm_stage_history_to_stage_ca5bd55f9f_enum),
+          ${changedByUserId},
+          NOW(),
+          NOW(),
+          NOW()
+        )
+      `);
     }
     async syncPersonSubtypeData(tx, personId, currentType, data, locale) {
         var _a, _b, _c;
@@ -2315,6 +2347,52 @@ let PersonService = PersonService_1 = class PersonService {
         }
         return null;
     }
+    async syncAccountArrays(tx, personId, data, locale) {
+        if (Object.prototype.hasOwnProperty.call(data, 'contacts')) {
+            const incomingContacts = Array.isArray(data.contacts) ? data.contacts : [];
+            this.validateSinglePrimaryPerType(incomingContacts, 'contact_type_id', locale, 'moreThanOnePrimaryContact', 'More than one contact of the same type cannot be marked as primary.');
+            await this.syncContacts(tx, personId, incomingContacts);
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'addresses')) {
+            const incomingAddresses = Array.isArray(data.addresses) ? data.addresses : [];
+            this.validateSinglePrimaryPerType(incomingAddresses, 'address_type', locale, 'moreThanOnePrimaryAddress', 'More than one address of the same type cannot be marked as primary.');
+            await this.syncAddresses(tx, personId, incomingAddresses, locale);
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'documents')) {
+            const incomingDocuments = Array.isArray(data.documents) ? data.documents : [];
+            this.validateSinglePrimaryPerType(incomingDocuments, 'document_type_id', locale, 'moreThanOnePrimaryDocument', 'More than one document of the same type cannot be marked as primary.');
+            await this.syncDocuments(tx, personId, incomingDocuments);
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'email')) {
+            await this.upsertPrimaryAccountContact(tx, personId, 'EMAIL', data.email);
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'phone')) {
+            await this.upsertPrimaryAccountContact(tx, personId, 'PHONE', data.phone);
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'collaborator_person_ids')) {
+            await this.attachCollaboratorsToCompany(tx, personId, data.collaborator_person_ids);
+        }
+    }
+    async attachCollaboratorsToCompany(tx, companyId, collaboratorPersonIds) {
+        const normalizedCollaboratorIds = Array.from(new Set((Array.isArray(collaboratorPersonIds) ? collaboratorPersonIds : [])
+            .map((value) => Number(value))
+            .filter((value) => Number.isInteger(value) && value > 0 && value !== companyId)));
+        if (normalizedCollaboratorIds.length === 0) {
+            return;
+        }
+        const collaborators = await tx.person.findMany({
+            where: {
+                id: { in: normalizedCollaboratorIds },
+                type: 'individual',
+            },
+            select: {
+                id: true,
+            },
+        });
+        for (const collaborator of collaborators) {
+            await this.upsertMetadataValue(tx, collaborator.id, EMPLOYER_COMPANY_METADATA_KEY, companyId);
+        }
+    }
     async syncContacts(tx, personId, incomingContacts) {
         const existingContacts = await tx.contact.findMany({ where: { person_id: personId } });
         for (const contact of incomingContacts) {
@@ -2740,62 +2818,86 @@ let PersonService = PersonService_1 = class PersonService {
         const priority = 'medium';
         const type = 'task';
         if (existing) {
-            await tx.crm_activity.update({
-                where: {
-                    id: existing.id,
-                },
-                data: {
-                    owner_user_id: ownerUserId,
-                    type,
-                    subject,
-                    notes: normalizedNotes,
-                    due_at: dueAtDate,
-                    priority,
-                    updated_at: new Date(),
-                },
-            });
+            await tx.$executeRaw(api_prisma_1.Prisma.sql `
+          UPDATE crm_activity
+          SET
+            owner_user_id = ${ownerUserId},
+            type = CAST(${'task'} AS crm_activity_type_77c8508dad_enum),
+            subject = ${this.getFollowupActivitySubject()},
+            notes = ${normalizedNotes},
+            due_at = CAST(${dueAt} AS TIMESTAMPTZ),
+            priority = CAST(${'medium'} AS crm_activity_priority_b4e2dbbb4d_enum),
+            updated_at = NOW()
+          WHERE id = ${existing.id}
+        `);
             return;
         }
-        const sourceKind = 'followup';
-        const now = new Date();
-        await tx.crm_activity.create({
-            data: {
-                person_id: personId,
-                owner_user_id: ownerUserId,
-                created_by_user_id: actorUserId,
-                type,
-                subject,
-                notes: normalizedNotes,
-                due_at: dueAtDate,
-                priority,
-                source_kind: sourceKind,
-                created_at: now,
-                updated_at: now,
-            },
-        });
+        await tx.$executeRaw(api_prisma_1.Prisma.sql `
+        INSERT INTO crm_activity (
+          person_id,
+          owner_user_id,
+          created_by_user_id,
+          type,
+          subject,
+          notes,
+          due_at,
+          priority,
+          source_kind,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${personId},
+          ${ownerUserId},
+          ${actorUserId},
+          CAST(${'task'} AS crm_activity_type_77c8508dad_enum),
+          ${this.getFollowupActivitySubject()},
+          ${normalizedNotes},
+          CAST(${dueAt} AS TIMESTAMPTZ),
+          CAST(${'medium'} AS crm_activity_priority_b4e2dbbb4d_enum),
+          CAST(${'followup'} AS crm_activity_source_kind_a09c5de478_enum),
+          NOW(),
+          NOW()
+        )
+      `);
     }
     async createCompletedInteractionActivity(tx, { personId, ownerUserId, interaction, actorUserId, }) {
         const completedAt = new Date(interaction.created_at);
         const type = interaction.type;
         const priority = 'medium';
         const sourceKind = 'interaction';
-        await tx.crm_activity.create({
-            data: {
-                person_id: personId,
-                owner_user_id: ownerUserId,
-                created_by_user_id: actorUserId,
-                completed_by_user_id: actorUserId,
-                type,
-                subject: this.getInteractionActivitySubject(interaction.type),
-                notes: this.normalizeTextOrNull(interaction.notes),
-                due_at: completedAt,
-                completed_at: completedAt,
-                priority,
-                source_kind: sourceKind,
-                created_at: completedAt,
-                updated_at: new Date(),
-            },
-        });
+        await tx.$executeRaw(api_prisma_1.Prisma.sql `
+        INSERT INTO crm_activity (
+          person_id,
+          owner_user_id,
+          created_by_user_id,
+          completed_by_user_id,
+          type,
+          subject,
+          notes,
+          due_at,
+          completed_at,
+          priority,
+          source_kind,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${personId},
+          ${ownerUserId},
+          ${actorUserId},
+          ${actorUserId},
+          CAST(${interaction.type} AS crm_activity_type_77c8508dad_enum),
+          ${this.getInteractionActivitySubject(interaction.type)},
+          ${this.normalizeTextOrNull(interaction.notes)},
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          CAST(${'medium'} AS crm_activity_priority_b4e2dbbb4d_enum),
+          CAST(${'interaction'} AS crm_activity_source_kind_a09c5de478_enum),
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          NOW()
+        )
+      `);
     }
     getFollowupActivitySubject() {
         return 'Follow-up';
@@ -3058,7 +3160,7 @@ let PersonService = PersonService_1 = class PersonService {
             filters.push(api_prisma_1.Prisma.sql `AND p.status = ${status}`);
         }
         if (lifecycleStage && lifecycleStage !== 'all') {
-            filters.push(api_prisma_1.Prisma.sql `AND pc.account_lifecycle_stage = ${lifecycleStage}`);
+            filters.push(api_prisma_1.Prisma.sql `AND pc.account_lifecycle_stage = CAST(${lifecycleStage} AS person_company_account_lifecycle_stage_680de09d00_enum)`);
         }
         if (search) {
             const searchLike = `%${search}%`;
@@ -3133,10 +3235,10 @@ let PersonService = PersonService_1 = class PersonService {
             filters.push(api_prisma_1.Prisma.sql `AND a.completed_at IS NOT NULL`);
         }
         if (type && type !== 'all') {
-            filters.push(api_prisma_1.Prisma.sql `AND a.type = ${type}`);
+            filters.push(api_prisma_1.Prisma.sql `AND a.type = CAST(${type} AS crm_activity_type_77c8508dad_enum)`);
         }
         if (priority && priority !== 'all') {
-            filters.push(api_prisma_1.Prisma.sql `AND a.priority = ${priority}`);
+            filters.push(api_prisma_1.Prisma.sql `AND a.priority = CAST(${priority} AS crm_activity_priority_b4e2dbbb4d_enum)`);
         }
         if (search) {
             const searchLike = `%${search}%`;
@@ -3283,6 +3385,318 @@ let PersonService = PersonService_1 = class PersonService {
             trade_name: tradeName,
         };
     }
+    // ─── CSV Import ──────────────────────────────────────────────────────────────
+    getUploadedFileText(file) {
+        let buffer = file.buffer;
+        if (!buffer || buffer.length === 0) {
+            throw new common_1.BadRequestException('Uploaded file is empty');
+        }
+        const utf8 = buffer.toString('utf8');
+        // Replace UTF-8 BOM if present
+        const withoutBom = utf8.replace(/^\uFEFF/, '');
+        if (withoutBom.includes('\uFFFD')) {
+            return buffer.toString('latin1').replace(/^\uFEFF/, '');
+        }
+        return withoutBom;
+    }
+    parseCsvRaw(content) {
+        const text = content.trimEnd();
+        if (!text)
+            return { columns: [], rows: [] };
+        // Detect delimiter from the first line before parsing the whole content
+        const firstNewlineIdx = text.indexOf('\n');
+        const firstLine = firstNewlineIdx === -1 ? text : text.slice(0, firstNewlineIdx);
+        const delimiter = firstLine.includes(';') ? ';' : ',';
+        // RFC 4180-compliant parser: character-by-character so quoted fields
+        // can span multiple lines without being split into separate records.
+        const records = [];
+        let row = [];
+        let field = '';
+        let inQuotes = false;
+        let i = 0;
+        const pushField = () => {
+            // For unquoted fields trim surrounding whitespace;
+            // for quoted fields the value is already the inner content.
+            row.push(inQuotes ? field : field.trim());
+            field = '';
+        };
+        const pushRow = () => {
+            pushField();
+            // Skip rows where every cell is empty (blank lines between records)
+            if (row.some((c) => c !== '')) {
+                records.push(row);
+            }
+            row = [];
+            inQuotes = false;
+        };
+        while (i < text.length) {
+            const ch = text[i];
+            if (inQuotes) {
+                if (ch === '"') {
+                    if (i + 1 < text.length && text[i + 1] === '"') {
+                        // Escaped double-quote ("") → literal "
+                        field += '"';
+                        i += 2;
+                    }
+                    else {
+                        // Closing quote — exit quoted mode; consume any trailing
+                        // whitespace before the next delimiter so malformed exports
+                        // like `"value" ;` don't include a trailing space.
+                        inQuotes = false;
+                        i++;
+                    }
+                }
+                else {
+                    // Newlines inside quoted fields are literal content, not record separators
+                    field += ch;
+                    i++;
+                }
+            }
+            else {
+                if (ch === '"' && field.trim() === '') {
+                    // Opening quote — only valid at the start of a field
+                    inQuotes = true;
+                    field = '';
+                    i++;
+                }
+                else if (ch === delimiter) {
+                    pushField();
+                    field = '';
+                    i++;
+                }
+                else if (ch === '\r' && i + 1 < text.length && text[i + 1] === '\n') {
+                    pushRow();
+                    i += 2;
+                }
+                else if (ch === '\n') {
+                    pushRow();
+                    i++;
+                }
+                else {
+                    field += ch;
+                    i++;
+                }
+            }
+        }
+        // Flush the last record (file may not end with a newline)
+        if (field || row.length > 0) {
+            row.push(inQuotes ? field : field.trim());
+            if (row.some((c) => c !== '')) {
+                records.push(row);
+            }
+        }
+        if (records.length === 0)
+            return { columns: [], rows: [] };
+        const columns = records[0].map((c) => c.trim());
+        const rows = records
+            .slice(1)
+            .filter((r) => r.some((c) => c !== ''))
+            .map((cells) => {
+            const row = {};
+            columns.forEach((col, idx) => {
+                var _a;
+                row[col] = ((_a = cells[idx]) !== null && _a !== void 0 ? _a : '').trim();
+            });
+            return row;
+        });
+        return { columns, rows };
+    }
+    async previewCsvImport(file) {
+        const MAX_ROWS = 5000;
+        const PREVIEW_ROWS = 20;
+        const content = this.getUploadedFileText(file);
+        const { columns, rows } = this.parseCsvRaw(content);
+        if (rows.length > MAX_ROWS) {
+            throw new common_1.BadRequestException(`File exceeds the maximum of ${MAX_ROWS} rows. Split the file and try again.`);
+        }
+        return {
+            fileName: file.originalname,
+            totalEstimated: rows.length,
+            columns,
+            preview: rows.slice(0, PREVIEW_ROWS),
+        };
+    }
+    async importFromCsv(file, mapping, companyId, locale, userId) {
+        var _a, _b, _c;
+        // 1. Validate the linked company, if provided
+        if (companyId) {
+            const company = await this.prismaService.person.findFirst({
+                where: { id: companyId, type: 'company' },
+                select: { id: true },
+            });
+            if (!company) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Company with ID ${companyId} not found.`));
+            }
+        }
+        // 1b. Validate mapping field names against allowed CRM fields
+        const validCrmFields = new Set(import_dto_1.CRM_IMPORT_FIELDS);
+        for (const val of Object.values(mapping)) {
+            if (!validCrmFields.has(val)) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.nameMustBeString', locale, `Invalid mapping field: "${val}"`));
+            }
+        }
+        // 2. Pre-fetch contact type IDs once (avoid per-row roundtrips)
+        const contactTypes = await this.prismaService.contact_type.findMany({
+            where: { code: { in: ['EMAIL', 'PHONE', 'MOBILE'] } },
+            select: { id: true, code: true },
+        });
+        const contactTypeMap = new Map(contactTypes.map((t) => [t.code.toUpperCase(), t.id]));
+        // 3. Pre-fetch document type IDs once
+        const documentTypes = await this.prismaService.document_type.findMany({
+            where: { code: { in: ['CPF', 'CNPJ'] } },
+            select: { id: true, code: true },
+        });
+        const documentTypeMap = new Map(documentTypes.map((t) => [t.code.toUpperCase(), t.id]));
+        // 4. Parse CSV content
+        const content = this.getUploadedFileText(file);
+        const { rows } = this.parseCsvRaw(content);
+        let imported = 0;
+        let skipped = 0;
+        const errors = [];
+        const BATCH_SIZE = 50;
+        for (let batchStart = 0; batchStart < rows.length; batchStart += BATCH_SIZE) {
+            const batch = rows.slice(batchStart, batchStart + BATCH_SIZE);
+            for (let i = 0; i < batch.length; i++) {
+                const rowIndex = batchStart + i + 2; // +2: 1-indexed and skip header row
+                const row = batch[i];
+                try {
+                    // Build a flat object: CRM field → CSV cell value
+                    const mapped = {};
+                    for (const [csvCol, crmField] of Object.entries(mapping)) {
+                        if (crmField !== '_ignore' && row[csvCol] !== undefined && row[csvCol] !== '') {
+                            mapped[crmField] = row[csvCol];
+                        }
+                    }
+                    // 'name' is mandatory — skip silently when absent
+                    const name = this.normalizeTextOrNull(mapped['name']);
+                    if (!name) {
+                        skipped++;
+                        continue;
+                    }
+                    // Coerce type (default: individual)
+                    const rawType = ((_a = mapped['type']) !== null && _a !== void 0 ? _a : '').toLowerCase();
+                    const personType = rawType === 'company' ||
+                        rawType === 'empresa' ||
+                        rawType === 'jurídica' ||
+                        rawType === 'juridica'
+                        ? 'company'
+                        : 'individual';
+                    // Coerce status (default: active)
+                    const rawStatus = ((_b = mapped['status']) !== null && _b !== void 0 ? _b : '').toLowerCase();
+                    const personStatus = rawStatus === 'inactive' || rawStatus === 'inativo' ? 'inactive' : 'active';
+                    // Run each row inside its own transaction so a bad row never rolls
+                    // back successfully imported rows
+                    await this.prismaService.$transaction(async (tx) => {
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+                        // (a) Base person record
+                        const person = await tx.person.create({
+                            data: { name, type: personType, status: personStatus },
+                        });
+                        // (b) Subtype-specific table (person_individual / person_company)
+                        await this.syncPersonSubtypeData(tx, person.id, null, {
+                            type: personType,
+                            job_title: personType === 'individual' ? ((_a = mapped['job_title']) !== null && _a !== void 0 ? _a : null) : null,
+                            trade_name: personType === 'company' ? ((_b = mapped['trade_name']) !== null && _b !== void 0 ? _b : null) : null,
+                            website: personType === 'company' ? ((_c = mapped['website']) !== null && _c !== void 0 ? _c : null) : null,
+                        }, locale);
+                        // (c) Metadata (notes, source, employer company, owner)
+                        await this.syncPersonMetadata(tx, person.id, {
+                            notes: (_d = mapped['notes']) !== null && _d !== void 0 ? _d : undefined,
+                            source: (_e = mapped['source']) !== null && _e !== void 0 ? _e : undefined,
+                            employer_company_id: personType === 'individual' && companyId ? companyId : undefined,
+                            owner_user_id: userId > 0 ? userId : undefined,
+                        });
+                        // (d) Contacts — email takes priority as primary
+                        let needsPrimary = true;
+                        const emailTypeId = contactTypeMap.get('EMAIL');
+                        if (mapped['email'] && emailTypeId) {
+                            await tx.contact.create({
+                                data: {
+                                    person_id: person.id,
+                                    contact_type_id: emailTypeId,
+                                    value: mapped['email'],
+                                    is_primary: true,
+                                },
+                            });
+                            needsPrimary = false;
+                        }
+                        const phoneTypeId = contactTypeMap.get('PHONE');
+                        if (mapped['phone'] && phoneTypeId) {
+                            await tx.contact.create({
+                                data: {
+                                    person_id: person.id,
+                                    contact_type_id: phoneTypeId,
+                                    value: mapped['phone'],
+                                    is_primary: needsPrimary,
+                                },
+                            });
+                            needsPrimary = false;
+                        }
+                        const mobileTypeId = contactTypeMap.get('MOBILE');
+                        if (mapped['mobile'] && mobileTypeId) {
+                            await tx.contact.create({
+                                data: {
+                                    person_id: person.id,
+                                    contact_type_id: mobileTypeId,
+                                    value: mapped['mobile'],
+                                    is_primary: needsPrimary,
+                                },
+                            });
+                        }
+                        // (e) Address — only created when at least one address field is present
+                        const hasAddress = mapped['address_street'] ||
+                            mapped['address_city'] ||
+                            mapped['address_state'] ||
+                            mapped['address_zip'] ||
+                            mapped['address_country'];
+                        if (hasAddress) {
+                            const address = await tx.address.create({
+                                data: {
+                                    line1: (_f = mapped['address_street']) !== null && _f !== void 0 ? _f : '',
+                                    line2: '',
+                                    city: (_g = mapped['address_city']) !== null && _g !== void 0 ? _g : '',
+                                    state: (_h = mapped['address_state']) !== null && _h !== void 0 ? _h : '',
+                                    country_code: mapped['address_country'] || 'BRA',
+                                    postal_code: (_j = mapped['address_zip']) !== null && _j !== void 0 ? _j : '',
+                                    is_primary: true,
+                                    address_type: 'residential',
+                                },
+                            });
+                            await tx.person_address.create({
+                                data: { person_id: person.id, address_id: address.id },
+                            });
+                        }
+                        // (f) Documents — the document table has no is_primary column
+                        const cpfTypeId = documentTypeMap.get('CPF');
+                        if (mapped['cpf'] && cpfTypeId) {
+                            await tx.document.create({
+                                data: {
+                                    person_id: person.id,
+                                    document_type_id: cpfTypeId,
+                                    value: mapped['cpf'],
+                                },
+                            });
+                        }
+                        const cnpjTypeId = documentTypeMap.get('CNPJ');
+                        if (mapped['cnpj'] && cnpjTypeId) {
+                            await tx.document.create({
+                                data: {
+                                    person_id: person.id,
+                                    document_type_id: cnpjTypeId,
+                                    value: mapped['cnpj'],
+                                },
+                            });
+                        }
+                    });
+                    imported++;
+                }
+                catch (err) {
+                    errors.push({ row: rowIndex, message: (_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : 'Unknown error' });
+                }
+            }
+        }
+        return { imported, skipped, errors };
+    }
 };
 exports.PersonService = PersonService;
 exports.PersonService = PersonService = PersonService_1 = __decorate([