brasil-ceps-offline 2.1.6 → 2.2.0

package/README.md

@@ -150,49 +150,8 @@ import type {
 
 ## ☁️ Deploy na Vercel / Next.js
 
-A Vercel não executa `postinstall` durante o build de produção por padrão. Siga os passos abaixo para garantir que o banco de dados seja baixado antes do deploy.
-
-### 1. Adicione o sync ao script de build (`package.json`)
-
-```json
-{
-  "scripts": {
-    "build": "npx brasil-ceps-offline sync ./public/.db && next build"
-  }
-}
-```
-
-### 2. Inclua o banco no rastreamento de arquivos (`next.config.js`)
-
-O Next.js usa **Output File Tracing** para empacotar apenas os arquivos necessários. O SQLite precisa ser incluído explicitamente:
-
-```js
-// next.config.js
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  experimental: {
-    outputFileTracingIncludes: {
-      // Inclui o banco para todas as rotas da API
-      '/api/**': [
-        './public/.db/**',
-        './node_modules/brasil-ceps-offline/.db/**',
-      ],
-    },
-  },
-};
-
-module.exports = nextConfig;
-```
-
-### 3. Variável de ambiente (opcional)
-
-Se preferir armazenar o banco fora de `node_modules` (ex: em `/tmp` na Vercel):
-
-```bash
-BRASIL_CEPS_DB_PATH=/tmp/ceps.sqlite
-```
-
-> **Atenção:** O diretório `/tmp` na Vercel é efêmero — o banco precisará ser baixado a cada cold start. Para produção de alta disponibilidade, use o caminho padrão via `node_modules`.
+Esta biblioteca é otimizada para **Node.js nativo** (APIs, serviços, workers).
+Ambientes serverless com filesystem restrito podem não suportar o comportamento do SQLite/WAL de forma consistente.
 
 ---
 

package/dist/bin/cli.js

@@ -15,7 +15,7 @@ function printHelp() {
 brasil-ceps-offline — CLI de gerenciamento do banco de dados
 
 Uso:
-  npx brasil-ceps-offline <comando> [destino]
+  npx brasil-ceps-offline <comando>
 
 Comandos:
   sync     Baixa ou atualiza o banco de dados para a versão mais recente
@@ -24,7 +24,6 @@ Comandos:
 
 Exemplos:
   npx brasil-ceps-offline sync
-  npx brasil-ceps-offline sync ./public/.db
   npx brasil-ceps-offline status
   `.trim());
 }
@@ -59,7 +58,7 @@ async function main() {
     const command = (process.argv[2] ?? 'help');
     switch (command) {
         case 'sync':
-            await (0, download_db_1.downloadDatabase)(process.argv[3]);
+            await (0, download_db_1.downloadDatabase)();
             break;
         case 'status':
             printStatus();

package/dist/config.js

@@ -5,40 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB_PATH = exports.DB_DIR = void 0;
 const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-/**
- * Resolve o diretório `.db` tentando múltiplos candidatos em ordem de prioridade.
- *
- * Prioridade:
- *  1. Vercel / Next.js build  — `<cwd>/node_modules/brasil-ceps-offline/.db`
- *  2. Instalação npm padrão   — dois níveis acima de `dist/scripts/` → `<pkg>/.db`
- *  3. Desenvolvimento local   — um nível acima de `dist/` → `<pkg>/.db`
- *  4. Variável de ambiente    — `BRASIL_CEPS_DB_PATH` (caminho completo para o .sqlite)
- *
- * Retorna o primeiro diretório que já contenha `ceps.sqlite`, ou o caminho
- * do candidato nº 1 como destino de instalação quando nenhum arquivo existe ainda.
- */
-function resolveDbDir() {
-    // Permite override total via env (útil em deploys customizados)
-    if (process.env.BRASIL_CEPS_DB_PATH) {
-        return path_1.default.dirname(process.env.BRASIL_CEPS_DB_PATH);
-    }
-    const candidates = [
-        // 1. Vercel/Next (cwd = raiz do projeto do usuário)
-        path_1.default.join(process.cwd(), 'node_modules', 'brasil-ceps-offline', '.db'),
-        // 2. npm install padrão: dist/scripts/ → ../../.db
-        path_1.default.join(__dirname, '..', '..', '.db'),
-        // 3. Fallback: dist/ → ../.db
-        path_1.default.join(__dirname, '..', '.db'),
-    ];
-    // Retorna o primeiro candidato que já tem o banco instalado
-    for (const dir of candidates) {
-        if (fs_1.default.existsSync(path_1.default.join(dir, 'ceps.sqlite'))) {
-            return dir;
-        }
-    }
-    // Nenhum banco encontrado → usa o candidato nº 1 como destino de instalação
-    return candidates[0];
-}
-exports.DB_DIR = resolveDbDir();
-exports.DB_PATH = process.env.BRASIL_CEPS_DB_PATH ?? path_1.default.join(exports.DB_DIR, 'ceps.sqlite');
+// Diretório `.db` dentro do pacote instalado: `<pkg>/.db`
+exports.DB_DIR = path_1.default.resolve(__dirname, '..', '.db');
+exports.DB_PATH = path_1.default.join(exports.DB_DIR, 'ceps.sqlite');

package/dist/index.js

@@ -22,46 +22,16 @@ const SELECT_ALL = `
 `;
 function log(msg) { console.log(`[brasil-ceps-offline] ${msg}`); }
 function resolveDatabasePath() {
-    const envPath = process.env.BRASIL_CEPS_DB_PATH;
-    if (envPath) {
-        if (!fs_1.default.existsSync(envPath)) {
-            throw new Error(`BRASIL_CEPS_DB_PATH definido, mas arquivo não existe: ${envPath}`);
-        }
-        return { dbPath: envPath, mode: 'env' };
-    }
-    const candidates = [
-        // Vercel runtime (path absoluto conhecido)
-        {
-            mode: 'serverless',
-            dbPath: path_1.default.join('/var/task', 'public', '.db', 'ceps.sqlite'),
-        },
-        {
-            mode: 'serverless',
-            dbPath: path_1.default.join(process.cwd(), 'public', '.db', 'ceps.sqlite'),
-        },
-        {
-            mode: 'node',
-            dbPath: path_1.default.join(process.cwd(), 'node_modules', 'brasil-ceps-offline', '.db', 'ceps.sqlite'),
-        },
-        {
-            mode: 'relative',
-            dbPath: path_1.default.join(__dirname, '..', '..', '.db', 'ceps.sqlite'),
-        },
-        {
-            mode: 'cwd',
-            dbPath: path_1.default.join(process.cwd(), '.db', 'ceps.sqlite'),
-        },
-    ];
-    for (const candidate of candidates) {
-        if (fs_1.default.existsSync(candidate.dbPath))
-            return candidate;
-    }
-    const tried = candidates.map((c) => `- ${c.dbPath}`).join('\n');
-    throw new Error(`Banco de dados não encontrado.\n` +
-        `process.cwd(): ${process.cwd()}\n` +
-        `__dirname: ${__dirname}\n` +
-        `Caminhos testados:\n${tried}\n` +
-        `Execute "npx brasil-ceps-offline sync" (Node) ou "npx brasil-ceps-offline sync ./public/.db" (Vercel/Next).`);
+    // Caminho principal: relativo ao pacote instalado (node_modules/brasil-ceps-offline/.db)
+    const primary = path_1.default.resolve(__dirname, '..', '.db', 'ceps.sqlite');
+    if (fs_1.default.existsSync(primary))
+        return primary;
+    // Fallback para monorepos: cwd do projeto consumidor
+    const monorepoFallback = path_1.default.join(process.cwd(), 'node_modules', 'brasil-ceps-offline', '.db', 'ceps.sqlite');
+    if (fs_1.default.existsSync(monorepoFallback))
+        return monorepoFallback;
+    throw new Error(`Erro: Banco de dados não encontrado em [${primary}]. ` +
+        `Rode "npx brasil-ceps-offline sync" para baixar.`);
 }
 /**
  * Motor de Inteligência Geográfica Offline para CEPs brasileiros.
@@ -86,44 +56,20 @@ class BrasilCepsOffline {
     initialize(_config) {
         if (this.isInitialized)
             return;
-        const { dbPath, mode } = resolveDatabasePath();
-        if (mode === 'serverless') {
-            log(`Modo Serverless detectado. Usando banco em ${path_1.default.join(process.cwd(), 'public', '.db')}`);
-        }
+        const dbPath = resolveDatabasePath();
         try {
-            // Valida explicitamente antes de instanciar o better-sqlite3 (evita erros opacos em serverless)
             if (!fs_1.default.existsSync(dbPath)) {
                 throw new Error(`Arquivo não existe: ${dbPath}`);
             }
-            this.db = new better_sqlite3_1.default(dbPath, { readonly: true, fileMustExist: true });
-            if (mode === 'serverless') {
-                // Em serverless (ex: Vercel), WAL pode tentar criar arquivos .wal/.shm e falhar em FS read-only.
-                // Força modo "leitura pura" e evita writes auxiliares no diretório do DB.
-                try {
-                    this.db.pragma('journal_mode = DELETE');
-                }
-                catch (err) {
-                    console.warn(`[brasil-ceps-offline] ⚠️  PRAGMA journal_mode=DELETE falhou: ${err.message}`);
-                }
-                try {
-                    this.db.pragma('synchronous = OFF');
-                }
-                catch (err) {
-                    console.warn(`[brasil-ceps-offline] ⚠️  PRAGMA synchronous=OFF falhou: ${err.message}`);
-                }
-                try {
-                    this.db.pragma('temp_store = MEMORY');
-                }
-                catch (err) {
-                    console.warn(`[brasil-ceps-offline] ⚠️  PRAGMA temp_store=MEMORY falhou: ${err.message}`);
-                }
-            }
-            this.db.pragma('cache_size = -32000'); // 32 MB cache
+            this.db = new better_sqlite3_1.default(dbPath, { readonly: true });
+            // Configurações de leitura para alta performance em Node.js (APIs)
+            this.db.pragma('journal_mode = WAL');
+            this.db.pragma('synchronous = NORMAL');
+            this.db.pragma('cache_size = 10000');
             this.isInitialized = true;
         }
         catch (error) {
-            throw new Error(`Falha ao abrir o banco de dados em [${dbPath}]. ` +
-                `process.cwd(): ${process.cwd()} | __dirname: ${__dirname} | erro: ${error}`);
+            throw new Error(`Falha ao abrir o banco de dados em [${dbPath}]: ${error}`);
         }
     }
     /**

package/dist/scripts/download-db.d.ts

@@ -1,2 +1,2 @@
-declare function downloadDatabase(customPath?: string): Promise<void>;
+declare function downloadDatabase(): Promise<void>;
 export { downloadDatabase };

package/dist/scripts/download-db.js

@@ -98,13 +98,13 @@ async function downloadAndExtract(url, dbPath) {
     log('Banco descompactado com sucesso.');
 }
 // ─── Ponto de entrada ─────────────────────────────────────────────────────────
-async function downloadDatabase(customPath) {
+async function downloadDatabase() {
     if (process.env.SKIP_POSTINSTALL_DB === 'true') {
         log('CI/CD detectado (SKIP_POSTINSTALL_DB=true). Pulando download.');
         return;
     }
-    const dbDir = customPath ? path_1.default.resolve(customPath) : config_1.DB_DIR;
-    const dbPath = customPath ? path_1.default.join(dbDir, 'ceps.sqlite') : config_1.DB_PATH;
+    const dbDir = config_1.DB_DIR;
+    const dbPath = config_1.DB_PATH;
     const versionFile = path_1.default.join(dbDir, 'version.json');
     // Garante que o diretório existe antes de qualquer operação
     if (!fs_1.default.existsSync(dbDir))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brasil-ceps-offline",
-  "version": "2.1.6",
+  "version": "2.2.0",
   "description": "Motor de Inteligência Geográfica Offline para CEPs brasileiros — dados do Censo IBGE 2022 com IBGE, DDD, fuso horário e coordenadas",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",