hobots 0.3.1 → 1.0.0

package/docs/manager.md

@@ -0,0 +1,90 @@
+# Manager
+
+Capability de **execução remota sob demanda**. O agente faz polling no app, executa os handlers registrados quando aparece trabalho e reporta status, logs incrementais e resultado. Entry próprio:
+
+```js
+import * as Manager from 'hobots/manager';
+```
+
+Independente do Monitor: credencial própria (**manager key**), singletons próprios e nenhum handler global instalado. Pode conviver com `Monitor.init()` no mesmo processo.
+
+## Ciclo de vida
+
+```js
+Manager.init({ dsn: 'http://<managerKey>@localhost:3002/<projectSlug>', agentName: 'VM Cliente 01' });
+
+Manager.register('processar-nfe', async (params, ctx) => {
+  ctx.log('info', `processando lote ${params.lote}…`);
+  if (ctx.signal.aborted) return; // cancelamento cooperativo
+  return { processadas: 12 }; // vira o resultado da execução no app
+});
+
+Manager.start(); // começa o polling e MANTÉM O PROCESSO VIVO
+
+process.on('SIGINT', () => {
+  void Manager.stop(15_000).then(() => process.exit(0));
+});
+```
+
+- `init(options)` — cria o agente (singleton). Chamar de novo para o anterior e substitui.
+- `register(task, handler)` — `task` é o `task_slug` configurado no formulário do app. Registre **antes** de `start()`.
+- `start()` — começa o polling. Lança se `init()` não foi chamado ou se nenhuma task foi registrada.
+- `stop(timeoutMs?)` — para o polling e aguarda as runs ativas (default 30s). Retorna `false` se estourou o timeout.
+
+> **Atenção:** ao contrário do Monitor, `Manager.start()` **segura o processo vivo** aguardando trabalho até `Manager.stop()` — o agente é a razão do processo existir.
+
+## O handler e o `RunContext`
+
+```ts
+type ManagerTaskHandler<P = Record<string, unknown>, R = unknown> =
+  (params: P, ctx: RunContext) => R | Promise<R>;
+
+interface RunContext {
+  runId: string;
+  task: string;
+  log(level: 'debug' | 'info' | 'warning' | 'error', message: string): void;
+  signal: AbortSignal;
+}
+```
+
+- **`params`** — os dados do formulário configurado no app (o JSON validado).
+- **`ctx.log(level, message)`** — logs enviados **incrementalmente** ao app (PATCHes com throttle), visíveis na run em tempo quase real.
+- **`ctx.signal`** — `AbortSignal` que dispara quando a run é **cancelada no app**, em **timeout** ou no **shutdown**. Cancelamento é cooperativo (veja abaixo).
+- **Retorno** — vira o resultado da execução exibido no app (serializado em JSON, cap de ~100KB; resultados maiores/circulares são descartados com um marcador `__truncated`).
+- **Erro lançado** — a run é reportada como `failed` com tipo/mensagem/stack (mensagem cap 10k, stack 20k).
+
+Você pode tipar params e retorno: `Manager.register<{ lote: number }, { processadas: number }>(...)`.
+
+## Cancelamento cooperativo
+
+Uma run cancelada no app **não mata** o seu handler — o SDK não interrompe código em execução. Ele apenas dispara `ctx.signal`. **Verifique `ctx.signal.aborted`** em loops longos e pontos de parada:
+
+```js
+Manager.register('processar-nfe', async (params, ctx) => {
+  for (const nota of params.notas) {
+    if (ctx.signal.aborted) {
+      ctx.log('warning', 'cancelamento detectado — parando');
+      return { canceladas: true };
+    }
+    await processar(nota);
+  }
+});
+```
+
+## Idempotência (at-least-once)
+
+A entrega é **at-least-once**: se o agente morrer logo após capturar uma run (antes de reportar o resultado), ela é re-entregue quando o agente voltar. Escreva handlers **idempotentes** — processar a mesma run duas vezes não pode causar efeito duplicado (use uma chave de deduplicação sua, como o número da nota).
+
+## Concorrência
+
+`concurrency` (default 1, máx 5) controla quantas runs o agente executa em paralelo. Com 1, as runs são sequenciais. O agente só reivindica o que consegue rodar (`max = concurrency - runs ativas`) e entra em **drain mode**: enquanto vêm runs, re-pesquisa imediatamente; quando não vem nada, espera `pollIntervalMs`.
+
+## Timeout por run
+
+`taskTimeoutMs` é um timeout **client-side**. No estouro o SDK **não mata** o handler — ele dispara `ctx.signal`, libera o slot de concorrência e reporta a run como falha (`TaskTimeout`). O handler pode continuar rodando em background; respeite o `signal` para parar de verdade. Sem `taskTimeoutMs`, o backstop é o servidor.
+
+Todas as opções em [Referência de API → ManagerInitOptions](./api-reference.md#managerinitoptions).
+
+## Como o claim funciona (resumo)
+
+O SDK é um cliente HTTP: ele faz `POST /api/manager/poll` e o **servidor** reivindica as runs pendentes de forma atômica com `FOR UPDATE SKIP LOCKED` — dois agentes nunca pegam a mesma run. Detalhes em [Protocolo & transporte](./protocol.md).

package/docs/monitor.md

@@ -0,0 +1,136 @@
+# Monitor
+
+Capability de telemetria: erros, performance, crons e uptime. Import raiz:
+
+```js
+import * as Monitor from 'hobots';
+```
+
+Todas as funções abaixo são no-op seguros se `Monitor.init()` não foi chamado (com aviso no console). Assinaturas completas em [Referência de API](./api-reference.md).
+
+## init
+
+```js
+Monitor.init({
+  dsn: 'http://<publicKey>@localhost:3002/<projectId>',
+  environment: 'production',
+  release: 'robo-nfe@1.4.2',
+  serverName: 'vm-cliente-01',
+  tags: { squad: 'automacoes' },
+  heartbeat: true,
+});
+```
+
+Cria o cliente, instala handlers globais de erro (a menos que `captureUnhandled: false`) e inicia o heartbeat se configurado. Chamar de novo substitui o cliente. Todos os campos em [Referência de API → InitOptions](./api-reference.md#initoptions).
+
+## Captura de erros e mensagens
+
+```js
+// exceções
+Monitor.captureException(error, {
+  tags: { cliente: 'acme' },
+  level: 'error',
+  fingerprint: ['sefaz-timeout'], // agrupa manualmente; sem isso o servidor agrupa pelo stack
+});
+
+// mensagens sem exceção
+Monitor.captureMessage('Lote processado com sucesso', 'info');
+```
+
+Ambas retornam o `event_id` (ou `undefined` se não inicializado). O segundo argumento é um [`CaptureHint`](./api-reference.md#capturehint) (`level`, `tags`, `extra`, `fingerprint`).
+
+Erros **não tratados** (`uncaughtException` / `unhandledRejection`) são capturados e flushados automaticamente antes do processo sair — desligue com `captureUnhandled: false`.
+
+## Breadcrumbs
+
+Trilha do que aconteceu antes do erro; enviada junto do próximo evento.
+
+```js
+Monitor.addBreadcrumb({ category: 'nfe', message: 'Baixou XML da nota 123', level: 'info' });
+```
+
+O buffer é limitado por `maxBreadcrumbs` (default 100, mais antigos descartados).
+
+## Escopo: tags, usuário, contexto, extras
+
+Dados anexados a **todos** os eventos seguintes:
+
+```js
+Monitor.setTag('regiao', 'nordeste');
+Monitor.setTags({ squad: 'automacoes', cliente: 'acme' });
+Monitor.setUser({ id: 'op-42', email: 'op@acme.com' });
+Monitor.setContext('vm', { cpu: 4, ram: '8GB' });
+Monitor.setExtra('ultimoLote', 128);
+```
+
+Para um escopo **isolado** (sem vazar para o global), use `withScope`:
+
+```js
+Monitor.withScope((scope) => {
+  scope.setTag('lote', '128').setFingerprint(['reprocessamento']);
+  Monitor.captureMessage('Reprocessando lote 128');
+});
+```
+
+## Performance: transactions e spans
+
+```js
+const tx = Monitor.startTransaction('processar-lote', 'rpa.job');
+
+const span = tx.startChild('http.client', 'GET /api/notas');
+await api.buscarNotas();
+span.setData('notas', 42).finish();
+
+const filho = span.startChild('db.query', 'INSERT INTO notas'); // spans aninham
+await gravar();
+filho.finish();
+
+tx.setStatus('ok'); // ou 'error'
+tx.finish(); // só aqui a transaction é enviada (respeitando tracesSampleRate)
+```
+
+- `startChild(op?, description?)` existe tanto em `Transaction` quanto em `Span` (aninhamento arbitrário).
+- Métodos encadeáveis: `setStatus`, `setData` (span), `setTag`/`setName` (transaction).
+- `finish()` na transaction fecha spans abertos e envia o payload; nada é enviado se ela não foi amostrada.
+
+## Crons (check-ins)
+
+Monitora jobs agendados: um check-in `in_progress` na entrada, `ok`/`error` na saída, com duração medida. O jeito recomendado é `withMonitor`, que faz o par e captura exceções:
+
+```js
+await Monitor.withMonitor(
+  'sync-notas',
+  () => executarSync(),
+  { schedule: '0 */2 * * *', timezone: 'America/Fortaleza' }
+);
+```
+
+O `schedule` (expressão cron) faz o servidor **criar/atualizar o monitor automaticamente** (upsert) e habilita a detecção de **execução perdida**. Para controle manual, use `checkIn` diretamente (veja [Referência](./api-reference.md#checkinoptions)):
+
+```js
+const id = Monitor.checkIn({ monitorSlug: 'sync-notas', status: 'in_progress' });
+// … trabalho …
+Monitor.checkIn({ monitorSlug: 'sync-notas', status: 'ok', checkInId: id, durationMs: 1234 });
+```
+
+## Heartbeat (uptime)
+
+Bate "estou vivo" periodicamente; o servidor acusa o robô **offline** quando os batimentos param.
+
+```js
+Monitor.init({
+  dsn,
+  heartbeat: { intervalMs: 30_000, name: 'Robô NFe — VM 01' },
+});
+```
+
+`heartbeat: true` usa os defaults. O `instanceId` default é o `serverName` / `HOSTNAME` / um id aleatório por processo. Campos em [HeartbeatOptions](./api-reference.md#heartbeatoptions).
+
+## Flush e close
+
+```js
+await Monitor.flush(2000); // envia o que está em buffer, mantém o SDK vivo
+await Monitor.close(2000); // flush final + para o heartbeat + fecha o transport
+```
+
+Chame `close` antes do processo sair. Os timers do Monitor são `unref`'d, então ele **não** segura o processo vivo sozinho.

package/docs/protocol.md

@@ -0,0 +1,87 @@
+# Protocolo & transporte
+
+O SDK é um **cliente HTTP puro**, sem dependências de runtime: ele só fala com o app da Hobots por HTTP. Não abre conexão com banco e **não** roda `SKIP LOCKED` — a reivindicação atômica de runs é server-side (veja o fim desta página).
+
+Os arquivos `src/protocol.ts` e `src/manager/protocol.ts` são a **fonte de verdade do wire format**: o app valida os payloads com zod travados nesses tipos (`satisfies z.ZodType<...>`), então não podem sofrer drift.
+
+## DSNs e endpoints derivados
+
+| Capability | DSN | Endpoint | Autenticação |
+| --- | --- | --- | --- |
+| Monitor | `<proto>://<publicKey>@host/<projectId>` | `<origin>/api/ingest/<publicKey>` | public key **na URL** (sem header) |
+| Manager | `<proto>://<managerKey>@host/<projectSlug>` | `<origin>/api/manager` | `Authorization: Bearer <managerKey>` (**nunca** na URL) |
+
+- Monitor: `parseDsn(dsn) → { publicKey, projectId, endpoint }`.
+- Manager: `parseManagerDsn(dsn) → { key, projectSlug, origin, baseUrl }`.
+
+## Monitor — ingestão
+
+Endpoint único `POST /api/ingest/<publicKey>` recebe **envelopes** JSON. O transport mantém uma fila em memória, agrupa itens em envelopes e faz POST via `fetch`.
+
+```jsonc
+{
+  "sdk": { "name": "hobots", "version": "1.0.0" },
+  "sent_at": "2024-01-01T00:00:00.000Z",
+  "items": [
+    { "type": "event",       "payload": { /* EventPayload */ } },
+    { "type": "transaction", "payload": { /* TransactionPayload */ } },
+    { "type": "check_in",    "payload": { /* CheckInPayload */ } },
+    { "type": "heartbeat",   "payload": { /* HeartbeatPayload */ } }
+  ]
+}
+```
+
+Tipos de item: `event`, `transaction`, `check_in`, `heartbeat` (definidos em `hobots/protocol`).
+
+**Flush & retries:** o transport flusha por `flushIntervalMs` (default 2s) ou ao atingir `maxBatchSize` (default 10). Ladder de retry `[1s, 4s, 16s]`; respostas 4xx (exceto 429) são descartadas sem retry; a fila tem teto de 200 itens (descarta os mais antigos).
+
+## Manager — polling e reporte
+
+Dois endpoints sob `<origin>/api/manager`, ambos com `Authorization: Bearer <managerKey>`:
+
+### `POST /api/manager/poll`
+
+Corpo `ManagerPollRequest`:
+
+```jsonc
+{
+  "agent": { "name": "VM 01", "version": "1.0.0", "host": "vm-01", "tasks": ["processar-nfe"] },
+  "max": 1,                       // quantas reivindicar (1..5)
+  "tasks": ["processar-nfe"]      // só runs destas tasks registradas
+}
+```
+
+Resposta `ManagerPollResponse` = `{ runs: ManagerRunDescriptor[] }`, cada `{ id, task, params, form, source, created_at }`.
+
+**Backoff:** um request por poll; o loop decide o ritmo. HTTP 401 (key rejeitada) → retry lento a 30s com log throttled; outros erros → ladder `[1s, 4s, 16s]`.
+
+### `PATCH /api/manager/runs/{id}`
+
+Corpo `ManagerRunUpdateRequest`:
+
+```jsonc
+{
+  "status": "running",            // 'running' | 'succeeded' | 'failed'
+  "logs":   [{ "ts": "…", "level": "info", "message": "…" }], // delta; o servidor concatena
+  "result": { "processadas": 12 },// só com 'succeeded'
+  "error":  { "type": "Error", "message": "…", "stack": "…" } // só com 'failed'
+}
+```
+
+- `status: 'running'` pode repetir para enviar **logs incrementais** (throttle por `logFlushIntervalMs`, flush ao acumular 20, chunk de 100, teto de 500 logs/run, mensagem cap 10k).
+- Ordem garantida `running → logs → terminal` (PATCHes serializados numa cadeia de promise).
+- Retry `[1s, 4s, 16s]`; 4xx exceto 429 é terminal (**409** = run cancelada / transição inválida → marca a run como morta e dispara `ctx.signal`).
+- `result` é serializado com cap de ~100KB (circular/grande → descartado com marcador `__truncated`).
+
+Ciclo de vida completo da run no servidor: `pending → claimed → running → succeeded | failed | canceled`. O agente só transiciona para `running`/`succeeded`/`failed`.
+
+## Onde vive o claim atômico
+
+O `POST /api/manager/poll` no app chama `claimPendingRuns()` em
+[`apps/webapp/lib/manager/claim.ts`](../../../apps/webapp/lib/manager/claim.ts): um CTE que seleciona runs `pending` vencidas com `FOR UPDATE SKIP LOCKED` e as promove a `claimed` num único `UPDATE ... RETURNING`. Isso garante que dois agentes concorrentes nunca peguem a mesma run. **Nada disso está no SDK** — ele só faz o HTTP.
+
+## Identidade do SDK
+
+`SDK_NAME = 'hobots'` e `SDK_VERSION` ficam em `src/utils.ts` e vão em todo envelope (campo `sdk`) e no `agent.version` do poll.
+
+> **Nota de manutenção:** `SDK_VERSION` é uma constante fixa e precisa ser mantida em sincronia com a `version` do `package.json` manualmente ao publicar.

package/package.json

@@ -1,5 +1,53 @@
 {
   "name": "hobots",
-  "version": "0.3.1",
-  "main": "./index.js"
+  "version": "1.0.0",
+  "description": "SDK JavaScript da Hobots — captura de erros, transactions, check-ins de cron e heartbeats (Monitor) e execução remota de tarefas sob demanda (Manager) para RPAs e integrações.",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "import": "./dist/protocol.js",
+      "require": "./dist/protocol.cjs"
+    },
+    "./manager": {
+      "types": "./dist/manager.d.ts",
+      "import": "./dist/manager.js",
+      "require": "./dist/manager.cjs"
+    },
+    "./manager/protocol": {
+      "types": "./dist/manager/protocol.d.ts",
+      "import": "./dist/manager/protocol.js",
+      "require": "./dist/manager/protocol.cjs"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsup": "^8.4.0",
+    "typescript": "5.7.3",
+    "@workspace/eslint-config": "0.0.0",
+    "@workspace/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint . --max-warnings 0",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/auth/index.d.ts

@@ -1,10 +0,0 @@
-export declare function authBot(bot_id: string): Promise<{
-    status: number;
-    data: any;
-    message: any;
-} | {
-    status: number;
-    message: any;
-    data?: undefined;
-}>;
-//# sourceMappingURL=index.d.ts.map

package/csv/index.d.ts

@@ -1,9 +0,0 @@
-type FetchCSVDataOptions = {
-    tag_name: string;
-    csv_name: string;
-    csv_default_dir?: string;
-    header: string[];
-};
-export declare function fetchCSVData(options: FetchCSVDataOptions): Promise<any>;
-export default fetchCSVData;
-//# sourceMappingURL=index.d.ts.map

package/datasets/index.d.ts

@@ -1,2 +0,0 @@
-export declare function fetchDataset(dataset_id: string, default_values?: any[], opts?: any): Promise<any[]>;
-//# sourceMappingURL=index.d.ts.map

package/db/drizzle.config.d.ts

@@ -1,8 +0,0 @@
-declare const _default: {
-    schema: string;
-    dialect: "sqlite";
-    verbose: true;
-    strict: true;
-};
-export default _default;
-//# sourceMappingURL=drizzle.config.d.ts.map

package/db/index.d.ts

@@ -1,9 +0,0 @@
-import * as schema from './schema';
-import { BetterSQLite3Database as Database } from 'drizzle-orm/better-sqlite3';
-export type { Database };
-export * from './migrate';
-export * from './storages';
-export * as schema from './schema';
-export declare function db(db_id: string): Database<typeof schema>;
-export default db;
-//# sourceMappingURL=index.d.ts.map

package/db/migrate.d.ts

@@ -1,3 +0,0 @@
-import { Database, schema } from './index';
-export declare function setupDB(db: Database<typeof schema>): Promise<void>;
-//# sourceMappingURL=migrate.d.ts.map

package/db/schema.d.ts

@@ -1,215 +0,0 @@
-export declare const jobs_table: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
-    name: "jobs";
-    schema: undefined;
-    columns: {
-        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "id";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: true;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        job_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "job_id";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        schema: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "schema";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        item_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "item_id";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "data";
-            tableName: "jobs";
-            dataType: "json";
-            columnType: "SQLiteTextJson";
-            data: unknown;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "status";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        status_text: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "status_text";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        started_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "started_at";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        done_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "done_at";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "created_at";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-        updated_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "updated_at";
-            tableName: "jobs";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
-    };
-    dialect: "sqlite";
-}>;
-//# sourceMappingURL=schema.d.ts.map

package/db/storages/base.d.ts

@@ -1,23 +0,0 @@
-import { Database, schema } from '../index';
-import { SQLiteTable } from 'drizzle-orm/sqlite-core';
-export type TableModel<T extends SQLiteTable> = T;
-export declare class Storage {
-    static db: Database<typeof schema>;
-    static model: TableModel<any>;
-    static transaction(fn: (tx: any) => Promise<any>): Promise<any>;
-    static query(tx?: Database): any;
-    static findById(id: any, options?: any, { tx }?: any): Promise<any>;
-    static findAll(where?: any, options?: any, { tx }?: any): Promise<any>;
-    static findOne(where: any, options?: any, { tx }?: any): Promise<any>;
-    static findOrCreate(where: any, data: any, opts?: any): Promise<any[]>;
-    static count(where?: any, opts?: any): Promise<number>;
-    static updateOrCreate(data: any, target?: any, opts?: any): Promise<any>;
-    static create(data: any, opts?: any): Promise<any>;
-    static bulkCreate(data: any, opts?: any): Promise<any>;
-    static update(id: any, data: any, opts?: any): Promise<any>;
-    static bulkUpdate(where: any, data: any, opts?: any): Promise<any>;
-    static destroy(where: any, opts?: any): Promise<any>;
-    static deleteById(id: any, opts?: any): Promise<any>;
-}
-export default Storage;
-//# sourceMappingURL=base.d.ts.map

package/db/storages/index.d.ts

@@ -1,3 +0,0 @@
-export * from './base';
-export * from './job';
-//# sourceMappingURL=index.d.ts.map