@meuecommerce/frete-adapter-node 0.3.0 → 0.4.0

package/dist/openAIDimensionEstimator.js

@@ -1,28 +1,38 @@
-const ESTIMATE_DIMENSIONS_TOOL = {
-    type: "function",
-    function: {
-        name: "estimate_dimensions",
-        description: "Estima dimensões de produtos PRESERVANDO os nomes exatos fornecidos",
-        parameters: {
-            type: "object",
-            properties: {
-                products: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            name: { type: "string" },
-                            length: { type: "number", description: "Comprimento em cm" },
-                            width: { type: "number", description: "Largura em cm" },
-                            height: { type: "number", description: "Altura em cm" },
-                        },
-                        required: ["name", "length", "width", "height"],
-                    },
+import { createOpenAIResponsesAgentRunner } from "./openAIResponsesAgentRunner.js";
+/**
+ * Bump whenever the prompt or the schema changes. It is written next to every
+ * `L3` record so a prompt change can invalidate stale estimates in background
+ * instead of at checkout.
+ */
+export const DIMENSION_PROMPT_VERSION = "2026-09-04.responses.v1";
+/**
+ * Strict JSON schema for the response.
+ *
+ * `strict: true` has two requirements that are easy to miss and reject the
+ * whole request when absent: every object needs `additionalProperties: false`,
+ * and `required` has to list every property — optional fields are not allowed.
+ */
+const DIMENSIONS_SCHEMA = {
+    type: "object",
+    properties: {
+        products: {
+            type: "array",
+            description: "Uma entrada por produto pedido, na mesma ordem.",
+            items: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "O nome EXATO recebido, sem reescrever" },
+                    length: { type: "number", description: "Comprimento em cm" },
+                    width: { type: "number", description: "Largura em cm" },
+                    height: { type: "number", description: "Altura em cm" },
                 },
+                required: ["name", "length", "width", "height"],
+                additionalProperties: false,
             },
-            required: ["products"],
         },
     },
+    required: ["products"],
+    additionalProperties: false,
 };
 function largestBox(boxes) {
     return boxes.reduce((largest, current) => current.width * current.height * current.length > largest.width * largest.height * largest.length ? current : largest);
@@ -40,8 +50,7 @@ function createPrompt(products, boxes, samples) {
         `🚨 LIMITES FÍSICOS OBRIGATÓRIOS:\n- Largura máxima: ${maxWidth}cm\n- Altura máxima: ${maxHeight}cm\n- Comprimento máximo: ${maxLength}cm\n(Maior caixa: ${box.name ?? "—"})\n\n` +
         `📦 PRODUTOS PARA ESTIMAR:\n${products.map((p, i) => `${i + 1}. ${p.name} - ${p.quantity}x (${p.weight}kg cada)`).join("\n")}\n` +
         samplesSection +
-        `\n⚠️ REGRAS: respeite os limites; preserve os nomes EXATOS; retorne length×width×height em cm.\n` +
-        `Responda usando a função 'estimate_dimensions'.`);
+        `\n⚠️ REGRAS: respeite os limites; preserve os nomes EXATOS; retorne length×width×height em cm.`);
 }
 /** Apply the largest-box physical limits + a minimum-volume floor to AI output. */
 function validateAndOptimize(aiResult, products, boxes) {
@@ -76,52 +85,32 @@ function validateAndOptimize(aiResult, products, boxes) {
     return { products: optimized };
 }
 export function createOpenAIDimensionEstimator(options) {
-    const { apiKey, fetch = globalThis.fetch, model = "gpt-4o-mini", temperature = 0.1, apiUrl = "https://api.openai.com/v1/chat/completions", timeoutMs = 20000, } = options;
-    if (!apiKey)
-        throw new Error("createOpenAIDimensionEstimator: apiKey is required");
-    if (typeof fetch !== "function")
-        throw new Error("createOpenAIDimensionEstimator: no fetch available");
+    const { apiKey, fetch, model = "gpt-4o-mini", temperature = 0.1, apiUrl, timeoutMs, runner } = options;
+    const agent = runner ??
+        createOpenAIResponsesAgentRunner({
+            apiKey: apiKey ?? "",
+            ...(fetch ? { fetch } : {}),
+            model,
+            ...(apiUrl ? { apiUrl } : {}),
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        });
     return {
         async estimate(products, boxes, productSamples = []) {
             if (!boxes.length)
                 throw new Error("estimate: no boxes provided");
-            const body = {
-                model,
-                messages: [
-                    {
-                        role: "system",
-                        content: "Você é um especialista em dimensões de produtos. Use os exemplos personalizados como prioridade máxima quando o nome bater.",
-                    },
-                    { role: "user", content: createPrompt(products, boxes, productSamples) },
-                ],
-                tools: [ESTIMATE_DIMENSIONS_TOOL],
-                tool_choice: { type: "function", function: { name: "estimate_dimensions" } },
+            const result = await agent.run({
+                task: "estimate-dimensions",
+                promptVersion: DIMENSION_PROMPT_VERSION,
+                system: "Você é um especialista em dimensões de produtos. Use os exemplos personalizados como prioridade máxima quando o nome bater.",
+                user: createPrompt(products, boxes, productSamples),
+                schema: { name: "product_dimensions", schema: DIMENSIONS_SCHEMA },
                 temperature,
-            };
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), timeoutMs);
-            let response;
-            try {
-                response = await fetch(apiUrl, {
-                    method: "POST",
-                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-                    body: JSON.stringify(body),
-                    signal: controller.signal,
-                });
+            });
+            if (!Array.isArray(result.output?.products)) {
+                throw new Error("Resposta da IA sem a lista de produtos");
             }
-            finally {
-                clearTimeout(timer);
-            }
-            if (!response.ok)
-                throw new Error(`OpenAI API Error: ${response.status} ${response.statusText}`);
-            const json = (await response.json());
-            if (json.error)
-                throw new Error(`OpenAI Error: ${json.error.message}`);
-            const args = json.choices?.[0]?.message?.tool_calls?.[0]?.function?.arguments;
-            if (!args)
-                throw new Error("IA não conseguiu estimar dimensões dos produtos");
-            const parsed = JSON.parse(args);
-            return validateAndOptimize(parsed, products, boxes);
+            const validated = validateAndOptimize(result.output, products, boxes);
+            return result.usage ? { ...validated, usage: result.usage } : validated;
         },
     };
 }

package/dist/openAIResponsesAgentRunner.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `LlmAgentRunner` on the OpenAI Responses API.
+ *
+ * One call, one strict schema, no re-ask. It owns everything provider-shaped —
+ * the endpoint, the structured-output envelope, reading the answer out of the
+ * two shapes the API returns it in, refusals, and token accounting — so each
+ * use case is left with only its prompt, its schema and its own validation.
+ *
+ * `fetch` is injectable (defaults to global fetch) so this also runs under Velo
+ * with `wix-fetch` passed in. The API key is passed in — the caller resolves it,
+ * keeping secret handling out of this module.
+ */
+import type { LlmAgentRunner } from "@meuecommerce/frete";
+type FetchLike = typeof globalThis.fetch;
+export interface OpenAIResponsesAgentRunnerOptions {
+    apiKey: string;
+    fetch?: FetchLike;
+    model?: string;
+    apiUrl?: string;
+    timeoutMs?: number;
+}
+interface ResponsesPayload {
+    error?: {
+        message?: string;
+    };
+    model?: string;
+    /** Convenience field with the text already concatenated. */
+    output_text?: string;
+    output?: Array<{
+        content?: Array<{
+            type?: string;
+            text?: string;
+            refusal?: string;
+        }>;
+    }>;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+}
+/** The model's text, accepting both shapes the Responses API delivers it in. */
+export declare function extractOutputText(json: ResponsesPayload): string;
+/**
+ * A refusal is a *successful* response in which the model declined to fill the
+ * schema. Without this check it would read as empty text and be reported as
+ * "the model could not answer", hiding the real reason.
+ */
+export declare function findRefusal(json: ResponsesPayload): string | null;
+export declare function createOpenAIResponsesAgentRunner(options: OpenAIResponsesAgentRunnerOptions): LlmAgentRunner;
+export {};

package/dist/openAIResponsesAgentRunner.js

@@ -0,0 +1,114 @@
+/** The model's text, accepting both shapes the Responses API delivers it in. */
+export function extractOutputText(json) {
+    if (typeof json.output_text === "string" && json.output_text.trim())
+        return json.output_text;
+    const parts = [];
+    for (const item of json.output ?? []) {
+        for (const content of item.content ?? []) {
+            if (typeof content.text === "string")
+                parts.push(content.text);
+        }
+    }
+    return parts.join("").trim();
+}
+/**
+ * A refusal is a *successful* response in which the model declined to fill the
+ * schema. Without this check it would read as empty text and be reported as
+ * "the model could not answer", hiding the real reason.
+ */
+export function findRefusal(json) {
+    for (const item of json.output ?? []) {
+        for (const content of item.content ?? []) {
+            if (typeof content.refusal === "string" && content.refusal)
+                return content.refusal;
+        }
+    }
+    return null;
+}
+export function createOpenAIResponsesAgentRunner(options) {
+    const { apiKey, fetch = globalThis.fetch, model: defaultModel = "gpt-4o-mini", apiUrl = "https://api.openai.com/v1/responses", timeoutMs = 20000, } = options;
+    if (!apiKey)
+        throw new Error("createOpenAIResponsesAgentRunner: apiKey is required");
+    if (typeof fetch !== "function")
+        throw new Error("createOpenAIResponsesAgentRunner: no fetch available");
+    return {
+        async run(request) {
+            const input = [];
+            if (request.system)
+                input.push({ role: "system", content: request.system });
+            // `images` ainda não é usado pelo estimador; quando a fase 2 ligar, o
+            // conteúdo do turno do usuário vira lista em vez de string.
+            if (request.images?.length) {
+                input.push({
+                    role: "user",
+                    content: [
+                        { type: "input_text", text: request.user },
+                        ...request.images.map((url) => ({ type: "input_image", image_url: url })),
+                    ],
+                });
+            }
+            else {
+                input.push({ role: "user", content: request.user });
+            }
+            const body = {
+                model: defaultModel,
+                input,
+                text: {
+                    format: {
+                        type: "json_schema",
+                        name: request.schema.name,
+                        strict: true,
+                        schema: request.schema.schema,
+                    },
+                },
+            };
+            if (request.temperature !== undefined)
+                body.temperature = request.temperature;
+            if (request.maxOutputTokens !== undefined)
+                body.max_output_tokens = request.maxOutputTokens;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            let response;
+            try {
+                response = await fetch(apiUrl, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!response.ok)
+                throw new Error(`OpenAI API Error: ${response.status} ${response.statusText}`);
+            const json = (await response.json());
+            if (json.error)
+                throw new Error(`OpenAI Error: ${json.error.message}`);
+            const refusal = findRefusal(json);
+            if (refusal)
+                throw new Error(`OpenAI recusou a resposta de ${request.task}: ${refusal}`);
+            const text = extractOutputText(json);
+            if (!text)
+                throw new Error(`Resposta vazia da IA para ${request.task}`);
+            let output;
+            try {
+                output = JSON.parse(text);
+            }
+            catch {
+                throw new Error(`Resposta da IA para ${request.task} não é JSON válido`);
+            }
+            const model = json.model ?? defaultModel;
+            const usage = json.usage
+                ? {
+                    model,
+                    ...(typeof json.usage.input_tokens === "number" ? { inputTokens: json.usage.input_tokens } : {}),
+                    ...(typeof json.usage.output_tokens === "number" ? { outputTokens: json.usage.output_tokens } : {}),
+                }
+                : undefined;
+            // Sempre 1 nesta fase: a repescagem por falha de validação é o próximo
+            // passo, e é ela que vai fazer este número variar.
+            return usage ? { output, usage, model, attempts: 1 } : { output, model, attempts: 1 };
+        },
+    };
+}

package/dist/pgDimensionMemory.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Postgres-backed `DimensionMemory` — the production counterpart of
+ * {@link InMemoryDimensionMemory}.
+ *
+ * Two rules from the port are enforced here in SQL rather than in application
+ * code, because the memory is written from more than one place (the quote path,
+ * the label feedback, the dashboard) and a check that lives in one caller is a
+ * check that the next caller forgets:
+ *
+ * - **A weaker layer never overwrites a stronger one.** The upsert carries the
+ *   layer's rank and only updates when the incoming rank is at least as strong,
+ *   so an agent estimate racing with a merchant's correction loses regardless of
+ *   which arrives last.
+ * - **One round trip per cart.** `get` takes every product at once, because a
+ *   query per line item is exactly what makes a hot path slow.
+ *
+ * The client is the structural {@link SqlClient} rather than a `pg` import, so
+ * this package gains no runtime dependency and the tests can run real SQL
+ * against pg-mem with no network.
+ *
+ * Lookups expand to `IN ($1, $2, …)` instead of the more idiomatic
+ * `= ANY($1)`. Real Postgres accepts both, but pg-mem silently returns zero
+ * rows for the array form, and running the tests against real SQL is worth more
+ * than the tidier query — a cart is a handful of line items, so the parameter
+ * count is not a concern. Revisit if this is ever used for bulk reads.
+ */
+import { canOverwrite } from "@meuecommerce/frete";
+import type { DimensionMemory, DimensionMemoryEntry, DimensionRecord, ProductIdentity } from "@meuecommerce/frete";
+/**
+ * Minimal query surface — satisfied structurally by a node-postgres
+ * `Pool`/`Client` and by pg-mem's adapter.
+ */
+export interface SqlClient {
+    query<R extends Record<string, unknown> = Record<string, unknown>>(text: string, params?: unknown[]): Promise<{
+        rows: R[];
+    }>;
+}
+export declare const DIMENSION_MEMORY_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS dimension_memory (\n  key             TEXT PRIMARY KEY,\n  instance_id     TEXT NOT NULL,\n  length_cm       DOUBLE PRECISION NOT NULL,\n  width_cm        DOUBLE PRECISION NOT NULL,\n  height_cm       DOUBLE PRECISION NOT NULL,\n  attrs           JSONB,\n  confidence      DOUBLE PRECISION NOT NULL,\n  source          TEXT NOT NULL,\n  layer_rank      INTEGER NOT NULL,\n  prompt_version  TEXT,\n  model           TEXT,\n  updated_at      TIMESTAMPTZ NOT NULL\n);\nCREATE INDEX IF NOT EXISTS dimension_memory_instance_idx ON dimension_memory (instance_id);\n";
+export interface PgDimensionMemoryOptions {
+    sql: SqlClient;
+}
+export declare class PgDimensionMemory implements DimensionMemory {
+    private readonly sql;
+    constructor(options: PgDimensionMemoryOptions);
+    /** Idempotent — safe to call on every boot. */
+    migrate(): Promise<void>;
+    get(identities: ProductIdentity[]): Promise<Map<string, DimensionRecord>>;
+    set(entries: DimensionMemoryEntry[]): Promise<void>;
+    invalidate(identities: ProductIdentity[]): Promise<void>;
+    /**
+     * Drop agent estimates produced by an older prompt.
+     *
+     * Only touches `L3`: what the merchant declared and what a real label proved
+     * do not go stale because we changed a prompt. Meant to run in background
+     * after a prompt bump — never on the quote path.
+     */
+    invalidateStaleEstimates(currentPromptVersion: string): Promise<number>;
+    /** Forget everything for one merchant — uninstall, or a support reset. */
+    forgetInstance(instanceId: string): Promise<number>;
+}
+/** Re-exported so callers can reason about precedence without importing core. */
+export { canOverwrite };

package/dist/pgDimensionMemory.js

@@ -0,0 +1,157 @@
+/**
+ * Postgres-backed `DimensionMemory` — the production counterpart of
+ * {@link InMemoryDimensionMemory}.
+ *
+ * Two rules from the port are enforced here in SQL rather than in application
+ * code, because the memory is written from more than one place (the quote path,
+ * the label feedback, the dashboard) and a check that lives in one caller is a
+ * check that the next caller forgets:
+ *
+ * - **A weaker layer never overwrites a stronger one.** The upsert carries the
+ *   layer's rank and only updates when the incoming rank is at least as strong,
+ *   so an agent estimate racing with a merchant's correction loses regardless of
+ *   which arrives last.
+ * - **One round trip per cart.** `get` takes every product at once, because a
+ *   query per line item is exactly what makes a hot path slow.
+ *
+ * The client is the structural {@link SqlClient} rather than a `pg` import, so
+ * this package gains no runtime dependency and the tests can run real SQL
+ * against pg-mem with no network.
+ *
+ * Lookups expand to `IN ($1, $2, …)` instead of the more idiomatic
+ * `= ANY($1)`. Real Postgres accepts both, but pg-mem silently returns zero
+ * rows for the array form, and running the tests against real SQL is worth more
+ * than the tidier query — a cart is a handful of line items, so the parameter
+ * count is not a concern. Revisit if this is ever used for bulk reads.
+ */
+import { MEMORY_LAYER_ORDER, canOverwrite, productKey } from "@meuecommerce/frete";
+export const DIMENSION_MEMORY_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS dimension_memory (
+  key             TEXT PRIMARY KEY,
+  instance_id     TEXT NOT NULL,
+  length_cm       DOUBLE PRECISION NOT NULL,
+  width_cm        DOUBLE PRECISION NOT NULL,
+  height_cm       DOUBLE PRECISION NOT NULL,
+  attrs           JSONB,
+  confidence      DOUBLE PRECISION NOT NULL,
+  source          TEXT NOT NULL,
+  layer_rank      INTEGER NOT NULL,
+  prompt_version  TEXT,
+  model           TEXT,
+  updated_at      TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS dimension_memory_instance_idx ON dimension_memory (instance_id);
+`;
+/** Lower rank = stronger layer, matching `MEMORY_LAYER_ORDER`. */
+function layerRank(layer) {
+    const rank = MEMORY_LAYER_ORDER.indexOf(layer);
+    // Uma camada desconhecida é tratada como a mais fraca possível, em vez de
+    // virar -1 e passar por cima de tudo.
+    return rank === -1 ? MEMORY_LAYER_ORDER.length : rank;
+}
+/** `$1, $2, …` para `count` parâmetros. */
+function placeholders(count) {
+    return Array.from({ length: count }, (_, i) => `$${i + 1}`).join(", ");
+}
+/** `DOUBLE PRECISION` chega como string em alguns drivers. */
+function num(value) {
+    return typeof value === "number" ? value : Number(value);
+}
+function toRecord(row) {
+    const updatedAt = row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at);
+    return {
+        dims: { length: num(row.length_cm), width: num(row.width_cm), height: num(row.height_cm) },
+        ...(row.attrs ? { attrs: row.attrs } : {}),
+        confidence: num(row.confidence),
+        source: row.source,
+        ...(row.prompt_version ? { promptVersion: row.prompt_version } : {}),
+        ...(row.model ? { model: row.model } : {}),
+        updatedAt,
+    };
+}
+export class PgDimensionMemory {
+    sql;
+    constructor(options) {
+        this.sql = options.sql;
+    }
+    /** Idempotent — safe to call on every boot. */
+    async migrate() {
+        await this.sql.query(DIMENSION_MEMORY_SCHEMA_SQL);
+    }
+    async get(identities) {
+        const keys = identities.flatMap((identity) => {
+            const key = productKey(identity);
+            return key ? [key.value] : [];
+        });
+        const found = new Map();
+        if (keys.length === 0)
+            return found;
+        const { rows } = await this.sql.query(`SELECT key, length_cm, width_cm, height_cm, attrs, confidence, source, prompt_version, model, updated_at
+         FROM dimension_memory
+        WHERE key IN (${placeholders(keys.length)})`, keys);
+        for (const row of rows)
+            found.set(row.key, toRecord(row));
+        return found;
+    }
+    async set(entries) {
+        const values = [];
+        const tuples = [];
+        for (const { identity, record } of entries) {
+            const key = productKey(identity);
+            // Sem chave derivável não há o que gravar: inventar uma faria produtos
+            // sem relação compartilharem entrada.
+            if (!key)
+                continue;
+            const base = values.length;
+            values.push(key.value, identity.instanceId, record.dims.length, record.dims.width, record.dims.height, record.attrs ? JSON.stringify(record.attrs) : null, record.confidence, record.source, layerRank(record.source), record.promptVersion ?? null, record.model ?? null, record.updatedAt);
+            const p = (offset) => `$${base + offset}`;
+            tuples.push(`(${p(1)}, ${p(2)}, ${p(3)}, ${p(4)}, ${p(5)}, ${p(6)}::jsonb, ${p(7)}, ${p(8)}, ${p(9)}, ${p(10)}, ${p(11)}, ${p(12)}::timestamptz)`);
+        }
+        if (tuples.length === 0)
+            return;
+        await this.sql.query(`INSERT INTO dimension_memory
+         (key, instance_id, length_cm, width_cm, height_cm, attrs, confidence, source, layer_rank, prompt_version, model, updated_at)
+       VALUES ${tuples.join(", ")}
+       ON CONFLICT (key) DO UPDATE SET
+         length_cm      = EXCLUDED.length_cm,
+         width_cm       = EXCLUDED.width_cm,
+         height_cm      = EXCLUDED.height_cm,
+         attrs          = EXCLUDED.attrs,
+         confidence     = EXCLUDED.confidence,
+         source         = EXCLUDED.source,
+         layer_rank     = EXCLUDED.layer_rank,
+         prompt_version = EXCLUDED.prompt_version,
+         model          = EXCLUDED.model,
+         updated_at     = EXCLUDED.updated_at
+       WHERE EXCLUDED.layer_rank <= dimension_memory.layer_rank`, values);
+    }
+    async invalidate(identities) {
+        const keys = identities.flatMap((identity) => {
+            const key = productKey(identity);
+            return key ? [key.value] : [];
+        });
+        if (keys.length === 0)
+            return;
+        await this.sql.query(`DELETE FROM dimension_memory WHERE key IN (${placeholders(keys.length)})`, keys);
+    }
+    /**
+     * Drop agent estimates produced by an older prompt.
+     *
+     * Only touches `L3`: what the merchant declared and what a real label proved
+     * do not go stale because we changed a prompt. Meant to run in background
+     * after a prompt bump — never on the quote path.
+     */
+    async invalidateStaleEstimates(currentPromptVersion) {
+        const { rows } = await this.sql.query(`DELETE FROM dimension_memory
+        WHERE source = 'L3' AND (prompt_version IS NULL OR prompt_version <> $1)
+        RETURNING key`, [currentPromptVersion]);
+        return rows.length;
+    }
+    /** Forget everything for one merchant — uninstall, or a support reset. */
+    async forgetInstance(instanceId) {
+        const { rows } = await this.sql.query(`DELETE FROM dimension_memory WHERE instance_id = $1 RETURNING key`, [instanceId]);
+        return rows.length;
+    }
+}
+/** Re-exported so callers can reason about precedence without importing core. */
+export { canOverwrite };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meuecommerce/frete-adapter-node",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Node implementation of @meuecommerce/frete ports (Correios HTTP client) using global fetch. Used by the Shopify/Fly deployment and the MCP server.",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -31,7 +31,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@meuecommerce/frete": "^0.3.0"
+    "@meuecommerce/frete": "^0.4.0"
   },
-  "module": "./dist/index.js"
+  "module": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devstudio163/frete.git",
+    "directory": "packages/adapter-node"
+  },
+  "homepage": "https://github.com/devstudio163/frete",
+  "devDependencies": {
+    "pg-mem": "^3.0.14"
+  }
 }