@danielarndt0/cnpj-db-loader 2.3.0 → 2.4.0-beta.1

package/dist/index.js

@@ -3269,6 +3269,15 @@ function createFieldValueParser(dataType) {
       };
   }
 }
+function toDatabaseValue(dataType, rawValue) {
+  return createFieldValueParser(dataType)(rawValue);
+}
+function normalizeCode(value, fallback) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return value.trim();
+  }
+  return fallback;
+}
 function createPartnerDedupeKeyBuilder(indices) {
   const orderedIndices = [
     indices.cnpjRoot,
@@ -3296,6 +3305,60 @@ function createEstablishmentCnpjFullBuilder(indices) {
     return `${root}${order}${digits}`;
   };
 }
+function buildPartnerDedupeKey(recordByColumn) {
+  return [
+    recordByColumn.cnpj_root,
+    recordByColumn.partner_type_code,
+    recordByColumn.partner_name,
+    recordByColumn.partner_document,
+    recordByColumn.partner_qualification_code,
+    recordByColumn.entry_date,
+    recordByColumn.country_code,
+    recordByColumn.legal_representative_document,
+    recordByColumn.legal_representative_name,
+    recordByColumn.legal_representative_qualification_code,
+    recordByColumn.age_group_code
+  ].map((value) => value == null ? "" : String(value).trim()).join("|");
+}
+function transformRecord(dataset, layout, rawFields, schemaCapabilities, writeTarget) {
+  const values = layout.fields.map(
+    (field, index) => toDatabaseValue(field.dataType, rawFields[index] ?? "")
+  );
+  const recordByColumn = Object.fromEntries(
+    layout.fields.map((field, index) => [field.columnName, values[index]])
+  );
+  if (dataset === "companies") {
+    recordByColumn.company_size_code = normalizeCode(
+      recordByColumn.company_size_code,
+      "00"
+    );
+  }
+  if (dataset === "establishments") {
+    recordByColumn.branch_type_code = normalizeCode(
+      recordByColumn.branch_type_code,
+      "1"
+    );
+    recordByColumn.registration_status_code = normalizeCode(
+      recordByColumn.registration_status_code,
+      "01"
+    );
+  }
+  const normalizedValues = layout.fields.map(
+    (field) => recordByColumn[field.columnName]
+  );
+  if (writeTarget === "final") {
+    if (dataset === "establishments" && schemaCapabilities.includeEstablishmentCnpjFullInInsert) {
+      return [
+        ...normalizedValues,
+        `${recordByColumn.cnpj_root ?? ""}${recordByColumn.cnpj_order ?? ""}${recordByColumn.cnpj_check_digits ?? ""}`
+      ];
+    }
+    if (dataset === "partners" && schemaCapabilities.includePartnerDedupeKeyInInsert) {
+      return [...normalizedValues, buildPartnerDedupeKey(recordByColumn)];
+    }
+  }
+  return normalizedValues;
+}
 function buildParsedPayload(columns, values) {
   return Object.fromEntries(
     columns.map((column, index) => [column, values[index] ?? null])
@@ -3435,7 +3498,7 @@ function createImportRowNormalizer(input) {
       "cnpj_check_digits"
     )
   }) : null;
-  const buildPartnerDedupeKey = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
+  const buildPartnerDedupeKey2 = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
     cnpjRoot: resolveLayoutColumnIndex(input.layout, "cnpj_root"),
     partnerTypeCode: resolveLayoutColumnIndex(
       input.layout,
@@ -3495,8 +3558,8 @@ function createImportRowNormalizer(input) {
       if (buildEstablishmentCnpjFull) {
         values.push(buildEstablishmentCnpjFull(values));
       }
-      if (buildPartnerDedupeKey) {
-        values.push(buildPartnerDedupeKey(values));
+      if (buildPartnerDedupeKey2) {
+        values.push(buildPartnerDedupeKey2(values));
       }
       return {
         values,
@@ -8096,6 +8159,851 @@ async function syncFederalRevenueDataset(options = {}) {
     () => runFederalRevenueSyncPipeline(options, check.selectedReference)
   );
 }
+
+// src/services/postgres-direct/exporter.ts
+import { createWriteStream as createWriteStream3 } from "fs";
+import { mkdir as mkdir8, writeFile as writeFile5 } from "fs/promises";
+import path16 from "path";
+
+// src/services/postgres-direct/csv.ts
+function formatCsvValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return formatCsvValue(value.toISOString());
+  }
+  const text = String(value);
+  const shouldQuote = /[",\r\n]/.test(text);
+  if (!shouldQuote) {
+    return text;
+  }
+  return `"${text.replace(/"/g, '""')}"`;
+}
+function formatCsvRow(values) {
+  return values.map(formatCsvValue).join(",");
+}
+
+// src/services/postgres-direct/script.ts
+import path15 from "path";
+var STAGING_DATASETS = [
+  "companies",
+  "establishments",
+  "partners",
+  "simples_options"
+];
+var DOMAIN_DATASETS = [
+  "partner_qualifications",
+  "legal_natures",
+  "countries",
+  "cities",
+  "reasons",
+  "cnaes"
+];
+var STAGING_TABLE_BY_DATASET3 = {
+  companies: "staging_companies",
+  establishments: "staging_establishments",
+  partners: "staging_partners",
+  simples_options: "staging_simples_options"
+};
+function quoteSqlLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function normalizePathForPsql(filePath) {
+  return path15.resolve(filePath).replace(/\\/g, "/");
+}
+function csvCopyCommand(tableName, columns, filePath) {
+  const normalizedFilePath = normalizePathForPsql(filePath);
+  return `\\copy ${tableName} (${columns.join(", ")}) from ${quoteSqlLiteral(normalizedFilePath)} with (format csv, header true, delimiter ',', quote '"', escape '"', null '')`;
+}
+function receitaCopyCommand(tableName, columns, filePath) {
+  const normalizedFilePath = normalizePathForPsql(filePath);
+  return `\\copy ${tableName} (${columns.join(", ")}) from ${quoteSqlLiteral(normalizedFilePath)} with (format csv, header false, delimiter ';', quote '"', escape '"')`;
+}
+function datasetColumns(dataset) {
+  return DATASET_LAYOUTS[dataset].fields.map((field) => field.columnName);
+}
+function updateAssignments(columns, excludedColumns) {
+  return columns.filter((column) => !excludedColumns.includes(column)).map((column) => `${column} = excluded.${column}`).concat(["updated_at = now()"]).join(",\n  ");
+}
+function partnerDedupeExpression(alias) {
+  return [
+    "md5(",
+    `  coalesce(${alias}.cnpj_root, '') || '|' ||`,
+    `  coalesce(${alias}.partner_type_code, '') || '|' ||`,
+    `  coalesce(${alias}.partner_name, '') || '|' ||`,
+    `  coalesce(${alias}.partner_document, '') || '|' ||`,
+    `  coalesce(${alias}.partner_qualification_code, '') || '|' ||`,
+    `  coalesce((${alias}.entry_date - date '2000-01-01')::text, '') || '|' ||`,
+    `  coalesce(${alias}.country_code, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_document, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_name, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_qualification_code, '') || '|' ||`,
+    `  coalesce(${alias}.age_group_code, '')`,
+    ")"
+  ].join("\n");
+}
+function materializeCompaniesSql() {
+  const columns = companiesLayout.fields.map((field) => field.columnName);
+  return [
+    "\\echo 'Materializing companies...'",
+    "with source as (",
+    "  select",
+    `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    row_number() over (partition by source.cnpj_root order by source.staging_id desc) as dedupe_rank",
+    "  from staging_companies source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    ")",
+    `insert into companies (${columns.join(", ")})`,
+    `select ${columns.join(", ")}`,
+    "from deduped",
+    "on conflict (cnpj_root) do update set",
+    `  ${updateAssignments(columns, ["cnpj_root"])};`
+  ].join("\n");
+}
+function materializeEstablishmentsSql() {
+  const baseColumns = establishmentsLayout.fields.map(
+    (field) => field.columnName
+  );
+  const insertColumns = [...baseColumns, "cnpj_full"];
+  return [
+    "\\echo 'Materializing establishments and secondary CNAEs...'",
+    "with source as (",
+    "  select",
+    `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    source.cnpj_root || source.cnpj_order || source.cnpj_check_digits as cnpj_full,",
+    "    row_number() over (partition by source.cnpj_root || source.cnpj_order || source.cnpj_check_digits order by source.staging_id desc) as dedupe_rank",
+    "  from staging_establishments source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    "),",
+    "upserted as (",
+    `  insert into establishments (${insertColumns.join(", ")})`,
+    `  select ${insertColumns.join(", ")}`,
+    "  from deduped",
+    "  on conflict (cnpj_full) do update set",
+    `    ${updateAssignments(insertColumns, ["cnpj_root", "cnpj_order", "cnpj_check_digits", "cnpj_full"])}`,
+    "  returning cnpj_full",
+    "),",
+    "deleted_secondary_cnaes as (",
+    "  delete from establishment_secondary_cnaes target",
+    "  using (select cnpj_full from deduped) source_keys",
+    "  where target.cnpj_full = source_keys.cnpj_full",
+    "  returning 1",
+    "),",
+    "secondary_cnaes_source as (",
+    "  select distinct",
+    "    deduped.cnpj_full,",
+    "    btrim(cnae_code) as cnae_code",
+    "  from deduped",
+    "  cross join lateral unnest(string_to_array(deduped.secondary_cnaes_raw, ',')) as cnae_code",
+    "  where deduped.secondary_cnaes_raw is not null",
+    "    and deduped.secondary_cnaes_raw <> ''",
+    "    and btrim(cnae_code) <> ''",
+    ")",
+    "insert into establishment_secondary_cnaes (cnpj_full, cnae_code)",
+    "select cnpj_full, cnae_code",
+    "from secondary_cnaes_source",
+    "on conflict (cnpj_full, cnae_code) do nothing;"
+  ].join("\n");
+}
+function materializePartnersSql() {
+  const baseColumns = partnersLayout.fields.map((field) => field.columnName);
+  const insertColumns = [...baseColumns, "partner_dedupe_key"];
+  return [
+    "\\echo 'Materializing partners...'",
+    "with source as (",
+    "  select",
+    `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
+    `    ${partnerDedupeExpression("source")} as partner_dedupe_key`,
+    "  from staging_partners source",
+    "),",
+    "ranked as (",
+    "  select",
+    "    source.*,",
+    "    row_number() over (partition by source.partner_dedupe_key order by source.cnpj_root asc) as dedupe_rank",
+    "  from source",
+    "),",
+    "deduped as (",
+    "  select * from ranked where dedupe_rank = 1",
+    ")",
+    `insert into partners (${insertColumns.join(", ")})`,
+    `select ${insertColumns.join(", ")}`,
+    "from deduped",
+    "on conflict (partner_dedupe_key) do update set",
+    `  ${updateAssignments(insertColumns, ["partner_dedupe_key"])};`
+  ].join("\n");
+}
+function materializeSimplesSql() {
+  const columns = simplesLayout.fields.map((field) => field.columnName);
+  return [
+    "\\echo 'Materializing simples options...'",
+    "with source as (",
+    "  select",
+    `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    row_number() over (partition by source.cnpj_root order by source.staging_id desc) as dedupe_rank",
+    "  from staging_simples_options source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    ")",
+    `insert into simples_options (${columns.join(", ")})`,
+    `select ${columns.join(", ")}`,
+    "from deduped",
+    "on conflict (cnpj_root) do update set",
+    `  ${updateAssignments(columns, ["cnpj_root"])};`
+  ].join("\n");
+}
+function copyDomainSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const columns = datasetColumns(dataset);
+  const tempTable = `tmp_hybrid_${dataset}`;
+  const lines = [
+    `\\echo 'Loading ${dataset} lookup data...'`,
+    `drop table if exists ${tempTable};`,
+    `create temporary table ${tempTable} (code text, description text);`
+  ];
+  for (const file of files) {
+    lines.push(csvCopyCommand(tempTable, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${dataset} (${columns.join(", ")})`,
+    `select distinct on (code) ${columns.join(", ")}`,
+    `from ${tempTable}`,
+    "where code is not null and code <> ''",
+    "order by code",
+    "on conflict (code) do update set description = excluded.description;"
+  );
+  return lines;
+}
+function copyStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const tableName = STAGING_TABLE_BY_DATASET3[dataset];
+  if (!tableName) {
+    return [];
+  }
+  const columns = datasetColumns(dataset);
+  return [
+    `\\echo 'Loading ${dataset} staging data...'`,
+    ...files.map(
+      (file) => csvCopyCommand(tableName, columns, file.absolutePath)
+    )
+  ];
+}
+function csvFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
+  }
+  return grouped;
+}
+function directFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
+  }
+  return grouped;
+}
+function rawTableName(dataset) {
+  return `tmp_hybrid_raw_${dataset}`;
+}
+function createRawTempTableSql(dataset) {
+  const columns = DATASET_LAYOUTS[dataset].fields.map((field) => `  ${quoteIdentifier(field.columnName)} text`).join(",\n");
+  return [
+    `drop table if exists ${rawTableName(dataset)};`,
+    `create temporary table ${rawTableName(dataset)} (`,
+    columns,
+    ");"
+  ].join("\n");
+}
+function textExpression(alias, column) {
+  return `nullif(btrim(${alias}.${quoteIdentifier(column)}), '')`;
+}
+function dateExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' or ${value} = '00000000' then null`,
+    `  when ${value} ~ '^\\d{8}$' then to_date(${value}, 'YYYYMMDD')`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function numericExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' then null`,
+    `  when ${value} like '%,%' and ${value} like '%.%' then replace(replace(${value}, '.', ''), ',', '.')::numeric`,
+    `  when ${value} like '%,%' then replace(${value}, ',', '.')::numeric`,
+    `  else ${value}::numeric`,
+    "end"
+  ].join(" ");
+}
+function integerExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' then null`,
+    `  when ${value} ~ '^-?\\d+$' then ${value}::integer`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function booleanExpression(alias, column) {
+  const value = `lower(btrim(${alias}.${quoteIdentifier(column)}))`;
+  return [
+    "case",
+    `  when ${value} in ('1', 'true', 't', 'y', 'yes', 's') then true`,
+    `  when ${value} in ('0', 'false', 'f', 'n', 'no') then false`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function fieldExpression(dataset, field, alias) {
+  const column = field.columnName;
+  if (dataset === "companies" && column === "company_size_code") {
+    return `coalesce(${textExpression(alias, column)}, '00')`;
+  }
+  if (dataset === "establishments" && column === "branch_type_code") {
+    return `coalesce(${textExpression(alias, column)}, '1')`;
+  }
+  if (dataset === "establishments" && column === "registration_status_code") {
+    return `coalesce(${textExpression(alias, column)}, '01')`;
+  }
+  switch (field.dataType) {
+    case "date":
+      return dateExpression(alias, column);
+    case "numeric":
+      return numericExpression(alias, column);
+    case "integer":
+      return integerExpression(alias, column);
+    case "boolean":
+      return booleanExpression(alias, column);
+    default:
+      return textExpression(alias, column);
+  }
+}
+function rawDomainSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const layout = DATASET_LAYOUTS[dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  const tableName = rawTableName(dataset);
+  const lines = [
+    `\\echo 'Loading ${dataset} lookup data directly from sanitized Receita files...'`,
+    createRawTempTableSql(dataset)
+  ];
+  for (const file of files) {
+    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${dataset} (${columns.join(", ")})`,
+    "select distinct on (code)",
+    "  nullif(btrim(code), '') as code,",
+    "  nullif(btrim(description), '') as description",
+    `from ${tableName}`,
+    "where nullif(btrim(code), '') is not null",
+    "order by code",
+    "on conflict (code) do update set description = excluded.description;"
+  );
+  return lines;
+}
+function rawStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const targetTable = STAGING_TABLE_BY_DATASET3[dataset];
+  if (!targetTable) {
+    return [];
+  }
+  const layout = DATASET_LAYOUTS[dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  const tableName = rawTableName(dataset);
+  const alias = "source";
+  const expressions = layout.fields.map(
+    (field) => `  ${fieldExpression(dataset, field, alias)} as ${field.columnName}`
+  );
+  const lines = [
+    `\\echo 'Loading ${dataset} staging data directly from sanitized Receita files...'`,
+    createRawTempTableSql(dataset)
+  ];
+  for (const file of files) {
+    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${targetTable} (${columns.join(", ")})`,
+    "select",
+    expressions.join(",\n"),
+    `from ${tableName} ${alias};`
+  );
+  return lines;
+}
+function generatePostgresDirectImportScript(input) {
+  const grouped = csvFilesByDataset(input.files);
+  const lines = [
+    "-- CNPJ DB Loader hybrid PostgreSQL import script",
+    "-- Generated from PostgreSQL-ready CSV files exported by cnpj-db-loader postgres export-csv.",
+    "-- Execute with psql, for example:",
+    '--   psql "postgres://postgres:postgres@localhost:5432/cnpj" -f import-postgres-direct.sql',
+    "",
+    "\\set ON_ERROR_STOP on",
+    "\\echo 'Starting CNPJ DB Loader hybrid PostgreSQL import...'",
+    "",
+    "begin;",
+    "",
+    "-- Keep the final schema and seed data managed by sql/schema.sql.",
+    "-- This script only resets staging tables and then upserts final data.",
+    "truncate table staging_companies restart identity;",
+    "truncate table staging_establishments restart identity;",
+    "truncate table staging_partners restart identity;",
+    "truncate table staging_simples_options restart identity;",
+    ""
+  ];
+  for (const dataset of DOMAIN_DATASETS) {
+    lines.push(...copyDomainSql(dataset, grouped[dataset] ?? []), "");
+  }
+  for (const dataset of STAGING_DATASETS) {
+    lines.push(...copyStagingSql(dataset, grouped[dataset] ?? []), "");
+  }
+  lines.push(...materializationAndAnalyzeSql());
+  return lines.join("\n");
+}
+function generatePostgresSanitizedDirectImportScript(input) {
+  const grouped = directFilesByDataset(input.files);
+  const lines = [
+    "-- CNPJ DB Loader direct PostgreSQL import script",
+    "-- Generated from sanitized Receita files by cnpj-db-loader postgres generate-script.",
+    "-- This path avoids rewriting the dataset into a second CSV tree.",
+    "-- Execute with psql, for example:",
+    '--   psql "postgres://postgres:postgres@localhost:5432/cnpj" -f import-postgres-direct.sql',
+    "",
+    "\\set ON_ERROR_STOP on",
+    `\\echo 'Using source file encoding ${input.sourceEncoding} for psql copy operations...'`,
+    `set client_encoding to ${quoteSqlLiteral(input.sourceEncoding)};`,
+    "\\echo 'Starting CNPJ DB Loader direct PostgreSQL import from sanitized files...'",
+    "",
+    "begin;",
+    "",
+    "-- Keep the final schema and seed data managed by sql/schema.sql.",
+    "-- This script copies sanitized Receita files into temporary raw tables,",
+    "-- transforms values inside PostgreSQL, resets staging tables and upserts final data.",
+    "truncate table staging_companies restart identity;",
+    "truncate table staging_establishments restart identity;",
+    "truncate table staging_partners restart identity;",
+    "truncate table staging_simples_options restart identity;",
+    ""
+  ];
+  for (const dataset of DOMAIN_DATASETS) {
+    lines.push(...rawDomainSql(dataset, grouped[dataset] ?? []), "");
+  }
+  for (const dataset of STAGING_DATASETS) {
+    lines.push(...rawStagingSql(dataset, grouped[dataset] ?? []), "");
+  }
+  lines.push(...materializationAndAnalyzeSql());
+  return lines.join("\n");
+}
+function materializationAndAnalyzeSql() {
+  return [
+    materializeCompaniesSql(),
+    "",
+    materializeEstablishmentsSql(),
+    "",
+    materializePartnersSql(),
+    "",
+    materializeSimplesSql(),
+    "",
+    "\\echo 'Refreshing planner statistics...'",
+    "analyze companies;",
+    "analyze establishments;",
+    "analyze establishment_secondary_cnaes;",
+    "analyze partners;",
+    "analyze simples_options;",
+    "analyze cnaes;",
+    "analyze cities;",
+    "analyze countries;",
+    "analyze legal_natures;",
+    "analyze partner_qualifications;",
+    "analyze reasons;",
+    "",
+    "commit;",
+    "",
+    "\\echo 'CNPJ DB Loader hybrid PostgreSQL import completed.'",
+    ""
+  ];
+}
+
+// src/services/postgres-direct/exporter.ts
+var POSTGRES_DIRECT_SCHEMA_CAPABILITIES = {
+  includeEstablishmentCnpjFullInInsert: true,
+  includeEstablishmentSecondaryCnaesTable: true,
+  includePartnerDedupeKeyInInsert: true,
+  requiresLookupReconciliation: false
+};
+function defaultPostgresCsvOutputPath(inputPath) {
+  const baseName = path16.basename(inputPath);
+  return path16.join(path16.dirname(inputPath), `${baseName}-postgres-csv`);
+}
+function normalizeOutputFileName(relativePath) {
+  const parsed = path16.parse(relativePath);
+  const baseName = parsed.name || parsed.base || "dataset";
+  return path16.join(parsed.dir, `${baseName}.csv`);
+}
+function resolveDatasetOutputPath(outputPath, dataset, relativePath) {
+  return path16.join(outputPath, dataset, normalizeOutputFileName(relativePath));
+}
+function inferNextStep4(scriptPath) {
+  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+}
+async function writeCsvFile(input) {
+  const layout = DATASET_LAYOUTS[input.dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  await mkdir8(path16.dirname(input.outputFile), { recursive: true });
+  const output = createWriteStream3(input.outputFile, { encoding: "utf8" });
+  let rows = 0;
+  try {
+    output.write(`${formatCsvRow(columns)}
+`);
+    for await (const sourceLine of readImportSourceLines(input.inputFile)) {
+      if (sourceLine.rawLine.trim() === "") {
+        continue;
+      }
+      const parsed = parseImportSourceLine(sourceLine);
+      const normalizedFields = normalizeFieldCount(
+        parsed.fields,
+        layout.fields.length,
+        input.inputFile,
+        parsed.lineNumber
+      );
+      const values = transformRecord(
+        input.dataset,
+        layout,
+        normalizedFields,
+        POSTGRES_DIRECT_SCHEMA_CAPABILITIES,
+        "staging"
+      );
+      output.write(`${formatCsvRow(values)}
+`);
+      rows += 1;
+    }
+  } finally {
+    output.end();
+    await new Promise((resolve, reject) => {
+      output.on("finish", () => resolve());
+      output.on("error", (error) => reject(error));
+    });
+  }
+  return rows;
+}
+async function exportPostgresCsvDataset(inputPath, options = {}) {
+  if (options.dataset && !isImportDatasetType(options.dataset)) {
+    throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
+  }
+  const validation = await validateInputDirectory(inputPath);
+  if (!validation.ok) {
+    throw new ValidationError(
+      `The input directory is not ready for PostgreSQL CSV export. ${validation.errors.join(" ")}`
+    );
+  }
+  const validatedPath = validation.validatedPath;
+  const outputPath = path16.resolve(
+    options.outputPath ?? defaultPostgresCsvOutputPath(validatedPath)
+  );
+  const inspected = await inspectFiles(validatedPath);
+  const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
+    if (!isImportDatasetType(entry.inferredType)) {
+      return [];
+    }
+    if (options.dataset && entry.inferredType !== options.dataset) {
+      return [];
+    }
+    return [{ ...entry, inferredType: entry.inferredType }];
+  }).sort(sortEntries);
+  if (recognizedFiles.length === 0) {
+    throw new ValidationError(
+      "No recognized dataset files were found for PostgreSQL CSV export."
+    );
+  }
+  const datasets = [
+    ...new Set(recognizedFiles.map((entry) => entry.inferredType))
+  ].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left) - IMPORT_ORDER.indexOf(right)
+  );
+  options.onProgress?.({
+    kind: "start",
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    totalFiles: recognizedFiles.length,
+    datasets
+  });
+  const exportedFiles = [];
+  const summariesByDataset = /* @__PURE__ */ new Map();
+  for (const [index, entry] of recognizedFiles.entries()) {
+    const dataset = entry.inferredType;
+    const inputFile = path16.join(validatedPath, entry.relativePath);
+    const outputFile = resolveDatasetOutputPath(
+      outputPath,
+      dataset,
+      entry.relativePath
+    );
+    options.onProgress?.({
+      kind: "file_start",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(inputFile),
+      outputFile
+    });
+    const rowCount = await writeCsvFile({ dataset, inputFile, outputFile });
+    exportedFiles.push({
+      dataset,
+      absolutePath: outputFile,
+      relativePath: path16.relative(outputPath, outputFile),
+      rowCount
+    });
+    const currentSummary = summariesByDataset.get(dataset) ?? {
+      dataset,
+      files: 0,
+      rows: 0,
+      outputFiles: []
+    };
+    currentSummary.files += 1;
+    currentSummary.rows += rowCount;
+    currentSummary.outputFiles.push(outputFile);
+    summariesByDataset.set(dataset, currentSummary);
+    options.onProgress?.({
+      kind: "file_finish",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(inputFile),
+      outputFile,
+      rows: rowCount
+    });
+  }
+  const scriptName = options.scriptName ?? "import-postgres-direct.sql";
+  const scriptPath = path16.join(outputPath, scriptName);
+  const script = generatePostgresDirectImportScript({ files: exportedFiles });
+  await writeFile5(scriptPath, script, "utf8");
+  const manifestPath = path16.join(outputPath, "manifest.json");
+  const summaryDatasets = [...summariesByDataset.values()].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
+  );
+  const totalRows = summaryDatasets.reduce((sum, item) => sum + item.rows, 0);
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    totalFiles: exportedFiles.length,
+    totalRows,
+    datasets: summaryDatasets
+  };
+  await writeFile5(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  options.onProgress?.({
+    kind: "finish",
+    outputPath,
+    scriptPath,
+    totalFiles: exportedFiles.length,
+    totalRows
+  });
+  return {
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    manifestPath,
+    totalFiles: exportedFiles.length,
+    totalRows,
+    datasets: summaryDatasets,
+    warnings: [
+      "PostgreSQL-ready CSV export is intended for hybrid bulk imports after extraction, validation and sanitization.",
+      "The generated SQL script resets staging tables and then upserts final tables. Review it before running against production databases."
+    ],
+    nextStep: inferNextStep4(scriptPath)
+  };
+}
+
+// src/services/postgres-direct/generator.ts
+import { mkdir as mkdir9, stat as stat7, writeFile as writeFile6 } from "fs/promises";
+import path17 from "path";
+var DEFAULT_SOURCE_ENCODING = "WIN1252";
+function defaultPostgresDirectOutputPath(inputPath) {
+  const baseName = path17.basename(inputPath);
+  if (baseName.toLowerCase() === "sanitized") {
+    return path17.join(path17.dirname(inputPath), "postgres-direct");
+  }
+  return path17.join(path17.dirname(inputPath), `${baseName}-postgres-direct`);
+}
+function inferNextStep5(scriptPath) {
+  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+}
+function normalizeSourceEncoding(value) {
+  const encoding = (value ?? DEFAULT_SOURCE_ENCODING).trim();
+  if (!/^[A-Za-z0-9_-]+$/.test(encoding)) {
+    throw new ValidationError(
+      `Invalid source encoding: ${value}. Use a PostgreSQL client encoding name such as WIN1252 or UTF8.`
+    );
+  }
+  return encoding.toUpperCase();
+}
+async function generatePostgresDirectScript(inputPath, options = {}) {
+  if (options.dataset && !isImportDatasetType(options.dataset)) {
+    throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
+  }
+  const validation = await validateInputDirectory(inputPath);
+  if (!validation.ok && !options.dataset) {
+    throw new ValidationError(
+      `The input directory is not ready for PostgreSQL direct script generation. ${validation.errors.join(" ")}`
+    );
+  }
+  const validatedPath = validation.ok ? validation.validatedPath : path17.resolve(inputPath);
+  const outputPath = path17.resolve(
+    options.outputPath ?? defaultPostgresDirectOutputPath(validatedPath)
+  );
+  const sourceEncoding = normalizeSourceEncoding(options.sourceEncoding);
+  const inspected = await inspectFiles(validatedPath);
+  const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
+    if (!isImportDatasetType(entry.inferredType)) {
+      return [];
+    }
+    if (options.dataset && entry.inferredType !== options.dataset) {
+      return [];
+    }
+    return [{ ...entry, inferredType: entry.inferredType }];
+  }).sort(sortEntries);
+  if (recognizedFiles.length === 0) {
+    throw new ValidationError(
+      "No recognized dataset files were found for PostgreSQL direct script generation."
+    );
+  }
+  const datasets = [
+    ...new Set(recognizedFiles.map((entry) => entry.inferredType))
+  ].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left) - IMPORT_ORDER.indexOf(right)
+  );
+  options.onProgress?.({
+    kind: "start",
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    totalFiles: recognizedFiles.length,
+    datasets,
+    sourceEncoding
+  });
+  await mkdir9(outputPath, { recursive: true });
+  const sourceFiles = [];
+  const summariesByDataset = /* @__PURE__ */ new Map();
+  for (const [index, entry] of recognizedFiles.entries()) {
+    const dataset = entry.inferredType;
+    const absolutePath = path17.join(validatedPath, entry.relativePath);
+    const fileStats = await stat7(absolutePath);
+    sourceFiles.push({
+      dataset,
+      absolutePath,
+      relativePath: entry.relativePath,
+      fileSize: fileStats.size
+    });
+    const currentSummary = summariesByDataset.get(dataset) ?? {
+      dataset,
+      files: 0,
+      totalBytes: 0,
+      sourceFiles: []
+    };
+    currentSummary.files += 1;
+    currentSummary.totalBytes += fileStats.size;
+    currentSummary.sourceFiles.push(absolutePath);
+    summariesByDataset.set(dataset, currentSummary);
+    options.onProgress?.({
+      kind: "file_registered",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(absolutePath),
+      fileSize: fileStats.size
+    });
+  }
+  const scriptName = options.scriptName ?? "import-postgres-direct.sql";
+  const scriptPath = path17.join(outputPath, scriptName);
+  const script = generatePostgresSanitizedDirectImportScript({
+    files: sourceFiles,
+    sourceEncoding
+  });
+  await writeFile6(scriptPath, script, "utf8");
+  const manifestPath = path17.join(outputPath, "manifest.json");
+  const summaryDatasets = [...summariesByDataset.values()].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
+  );
+  const totalBytes = summaryDatasets.reduce(
+    (sum, item) => sum + item.totalBytes,
+    0
+  );
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: "direct-sanitized-script",
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    sourceEncoding,
+    totalFiles: sourceFiles.length,
+    totalBytes,
+    datasets: summaryDatasets
+  };
+  await writeFile6(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  options.onProgress?.({
+    kind: "finish",
+    outputPath,
+    scriptPath,
+    totalFiles: sourceFiles.length,
+    totalBytes
+  });
+  return {
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    manifestPath,
+    sourceEncoding,
+    totalFiles: sourceFiles.length,
+    totalBytes,
+    datasets: summaryDatasets,
+    warnings: [
+      ...validation.ok ? [] : validation.errors,
+      "This script imports sanitized Receita files directly with psql \\copy. It avoids rewriting the full dataset into a second CSV tree.",
+      "The generated script expects the database schema generated by cnpj-db-loader to be applied before execution.",
+      "Use --source-encoding UTF8 only if your sanitized files are already UTF-8. The default WIN1252 matches the usual Receita file encoding."
+    ],
+    nextStep: inferNextStep5(scriptPath)
+  };
+}
 export {
   AppError,
   DEFAULT_FEDERAL_REVENUE_DOWNLOAD_ROOT,
@@ -8125,8 +9033,10 @@ export {
   ensureDirectory,
   evaluateFederalRevenueManifestFile,
   evaluateFederalRevenueManifestFiles,
+  exportPostgresCsvDataset,
   extractArchives,
   finalizeFederalRevenueManifest,
+  generatePostgresDirectScript,
   generateSchemaSql,
   getAllLayouts,
   getCurrentFederalRevenueReference,