@hebo-ai/gateway 0.9.2 → 0.9.3

package/dist/endpoints/conversations/storage/dialects/sqlite.js

@@ -0,0 +1,176 @@
+import { LRUCache } from "lru-cache";
+import { createParamsMapper, dateToNumber, escapeSqlString, jsonStringify } from "./utils";
+const mapParams = createParamsMapper([dateToNumber, jsonStringify]);
+export const SQLiteDialectConfig = {
+    placeholder: () => "?",
+    quote: (i) => `"${i}"`,
+    selectJson: (c) => c,
+    jsonExtract: (c, k) => `json_extract(${c}, '$.${escapeSqlString(k)}')`,
+    upsertSuffix: (q, pk, cols) => `ON CONFLICT (${pk.map((c) => q(c)).join(", ")}) DO UPDATE SET ${cols
+        .map((c) => `${q(c)} = EXCLUDED.${q(c)}`)
+        .join(", ")}`,
+    supportCreateIndexIfNotExists: true,
+    types: {
+        varchar: "TEXT",
+        json: "TEXT",
+        timestamp: "BIGINT",
+        index: "B-TREE",
+    },
+};
+const MAX_CACHE_SIZE = 100;
+function isBetterSqlite3(client) {
+    const c = client;
+    return !!client && typeof c["prepare"] === "function" && typeof c["transaction"] === "function";
+}
+function isLibsql(client) {
+    const c = client;
+    return !!client && typeof c["execute"] === "function" && typeof c["batch"] === "function";
+}
+function isBunSql(client) {
+    const c = client;
+    return !!client && typeof c["unsafe"] === "function" && typeof c["transaction"] === "function";
+}
+function createBetterSqlite3Executor(db) {
+    const cache = new LRUCache({ max: MAX_CACHE_SIZE });
+    const getStmt = (sql) => {
+        let stmt = cache.get(sql);
+        if (!stmt) {
+            stmt = db.prepare(sql);
+            cache.set(sql, stmt);
+        }
+        return stmt;
+    };
+    const executor = {
+        all(sql, params) {
+            const stmt = getStmt(sql);
+            return Promise.resolve(stmt.all.apply(stmt, mapParams(params) ?? []));
+        },
+        get(sql, params) {
+            const stmt = getStmt(sql);
+            return Promise.resolve(stmt.get.apply(stmt, mapParams(params) ?? []));
+        },
+        run(sql, params) {
+            const stmt = getStmt(sql);
+            const info = stmt.run.apply(stmt, mapParams(params) ?? []);
+            return Promise.resolve({ changes: info.changes });
+        },
+        async transaction(fn) {
+            const inTransaction = db.inTransaction;
+            if (inTransaction) {
+                const savepoint = `sp_${Math.random().toString(36).slice(2)}`;
+                db.exec(`SAVEPOINT ${savepoint}`);
+                try {
+                    const result = await fn(executor);
+                    db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                    return result;
+                }
+                catch (err) {
+                    db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+                    throw err;
+                }
+            }
+            else {
+                db.exec("BEGIN");
+                try {
+                    const result = await fn(executor);
+                    db.exec("COMMIT");
+                    return result;
+                }
+                catch (err) {
+                    db.exec("ROLLBACK");
+                    throw err;
+                }
+            }
+        },
+    };
+    return executor;
+}
+function createLibsqlExecutor(client) {
+    const executor = {
+        async all(sql, params) {
+            const rs = await client.execute({ sql, args: mapParams(params) ?? [] });
+            return rs.rows;
+        },
+        async get(sql, params) {
+            const rs = await client.execute({ sql, args: mapParams(params) ?? [] });
+            return rs.rows?.[0];
+        },
+        async run(sql, params) {
+            const rs = await client.execute({ sql, args: mapParams(params) ?? [] });
+            return { changes: rs.rowsAffected };
+        },
+        async transaction(fn) {
+            const tx = await client.transaction("deferred");
+            const txExecutor = {
+                async all(sql, params) {
+                    const rs = await tx.execute({ sql, args: mapParams(params) ?? [] });
+                    return rs.rows;
+                },
+                async get(sql, params) {
+                    const rs = await tx.execute({ sql, args: mapParams(params) ?? [] });
+                    return rs.rows?.[0];
+                },
+                async run(sql, params) {
+                    const rs = await tx.execute({ sql, args: mapParams(params) ?? [] });
+                    return { changes: rs.rowsAffected };
+                },
+                transaction(txCallback) {
+                    return txCallback(txExecutor);
+                },
+            };
+            try {
+                const result = await fn(txExecutor);
+                await tx.commit();
+                return result;
+            }
+            catch (err) {
+                await tx.rollback();
+                throw err;
+            }
+        },
+    };
+    return executor;
+}
+function createBunSqliteExecutor(sql) {
+    const executor = {
+        all(query, params) {
+            return sql.unsafe(query, mapParams(params));
+        },
+        async get(query, params) {
+            const rows = await sql.unsafe(query, mapParams(params));
+            return rows?.[0];
+        },
+        async run(query, params) {
+            const res = (await sql.unsafe(query, mapParams(params)));
+            const result = res;
+            return { changes: result.affectedRows ?? result.count ?? 0 };
+        },
+        transaction(fn) {
+            return sql.transaction((tx) => {
+                const txExecutor = createBunSqliteExecutor(tx);
+                txExecutor.transaction = (f) => f(txExecutor);
+                return fn(txExecutor);
+            });
+        },
+    };
+    return executor;
+}
+export class SqliteDialect {
+    executor;
+    config = SQLiteDialectConfig;
+    constructor(options) {
+        const { client } = options;
+        if (isBetterSqlite3(client)) {
+            this.executor = createBetterSqlite3Executor(client);
+        }
+        else if (isLibsql(client)) {
+            this.executor = createLibsqlExecutor(client);
+        }
+        else if (isBunSql(client)) {
+            this.executor = createBunSqliteExecutor(client);
+        }
+        else {
+            throw new Error("Unsupported SQLite client");
+        }
+    }
+}

package/dist/endpoints/conversations/storage/dialects/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Lightweight interface for Bun's SQL client.
+ *
+ * We define this locally instead of importing from "bun" to avoid leaking Bun-only
+ * types in our public API. This prevents TypeScript compilation errors for users
+ * who are not using Bun and don't have @types/bun installed.
+ *
+ * Because TypeScript uses structural typing, a real Bun SQL instance will still
+ * match this interface perfectly.
+ */
+export interface BunSql {
+    unsafe<T = any>(query: string, params?: unknown[]): Promise<T>;
+    transaction<T>(fn: (tx: BunSql) => Promise<T>): Promise<T>;
+}
+export interface QueryExecutor {
+    all<T>(sql: string, params?: unknown[]): Promise<T[]>;
+    get<T>(sql: string, params?: unknown[]): Promise<T | undefined>;
+    run(sql: string, params?: unknown[]): Promise<{
+        changes: number;
+    }>;
+    transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
+}
+export interface DialectConfig {
+    placeholder: (index: number) => string;
+    quote: (name: string) => string;
+    selectJson: (column: string) => string;
+    jsonExtract: (column: string, key: string) => string;
+    upsertSuffix?: (q: (n: string) => string, pk: string[], updateCols: string[]) => string;
+    supportCreateIndexIfNotExists?: boolean;
+    limitAsLiteral?: boolean;
+    partitionClause?: (columns: string[]) => string;
+    types: {
+        varchar: string;
+        json: string;
+        timestamp: string;
+        index: "BRIN" | "B-TREE" | "TIME";
+    };
+}
+export interface SqlDialect {
+    executor: QueryExecutor;
+    config: DialectConfig;
+}

package/dist/endpoints/conversations/storage/dialects/utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Normalizes a list of parameters by applying a chain of atomic mappers to each value.
+ */
+export declare function createParamsMapper(mappers: ((v: unknown) => unknown)[]): (params?: unknown[]) => (string | number | bigint | boolean | null)[];
+/**
+ * Normalizes an object (row) by applying a chain of atomic mappers.
+ * Mappers are expected to mutate the object for performance and to avoid spreads.
+ */
+export declare function createRowMapper<T>(mappers: ((row: Record<string, unknown>) => Record<string, unknown>)[]): (row: Record<string, unknown>) => T;
+/**
+ * Atomic mappers for input parameters.
+ */
+export declare const dateToNumber: (v: unknown) => unknown;
+export declare const dateToBigInt: (v: unknown) => unknown;
+export declare const jsonStringify: (v: unknown, asBinary?: boolean) => unknown;
+/**
+ * Escapes single quotes in a string for use in SQL literals.
+ */
+export declare const escapeSqlString: (str: string) => string;
+/**
+ * Atomic mappers for database rows.
+ */
+export declare const parseJson: (key: string) => (row: Record<string, unknown>) => Record<string, unknown>;
+export declare const toMilliseconds: (key: string) => (row: Record<string, unknown>) => Record<string, unknown>;
+export declare const mergeData: (key: string) => (row: Record<string, unknown>) => Record<string, unknown>;

package/dist/endpoints/conversations/storage/dialects/utils.js

@@ -0,0 +1,80 @@
+/**
+ * Generic utility to chain multiple functions together.
+ */
+function pipe(fns) {
+    return (v) => {
+        let result = v;
+        for (let i = 0; i < fns.length; i++) {
+            const fn = fns[i];
+            if (fn) {
+                result = fn(result);
+            }
+        }
+        return result;
+    };
+}
+/**
+ * Normalizes a list of parameters by applying a chain of atomic mappers to each value.
+ */
+export function createParamsMapper(mappers) {
+    const p = pipe(mappers);
+    return (params) => params?.map((v) => p(v));
+}
+/**
+ * Normalizes an object (row) by applying a chain of atomic mappers.
+ * Mappers are expected to mutate the object for performance and to avoid spreads.
+ */
+export function createRowMapper(mappers) {
+    const p = pipe(mappers);
+    return (row) => p(row);
+}
+/**
+ * Atomic mappers for input parameters.
+ */
+export const dateToNumber = (v) => (v instanceof Date ? v.getTime() : v);
+export const dateToBigInt = (v) => (v instanceof Date ? BigInt(v.getTime()) : v);
+export const jsonStringify = (v, asBinary = false) => v !== null && typeof v === "object" && !(v instanceof Date)
+    ? asBinary
+        ? new TextEncoder().encode(JSON.stringify(v))
+        : JSON.stringify(v)
+    : v;
+/**
+ * Escapes single quotes in a string for use in SQL literals.
+ */
+export const escapeSqlString = (str) => str.replaceAll("'", "''");
+/**
+ * WORKAROUND: GreptimeDB can return Rust-style Unicode escapes (\u{xxxx})
+ * inside JSON strings, which is invalid JSON and causes crashes in JSON.parse.
+ * This normalization converts those escapes back into literal characters before parsing.
+ */
+function normalizeJsonUnicodeEscapes(value) {
+    return value.replaceAll(/\\u\{([0-9a-fA-F]+)\}/g, (_, hex) => String.fromCodePoint(+`0x${hex}`));
+}
+/**
+ * Atomic mappers for database rows.
+ */
+export const parseJson = (key) => (row) => {
+    const val = row[key];
+    if (typeof val === "string") {
+        row[key] = val === "" || val === "{}" ? {} : JSON.parse(normalizeJsonUnicodeEscapes(val));
+    }
+    return row;
+};
+export const toMilliseconds = (key) => (row) => {
+    const v = row[key];
+    if (v instanceof Date) {
+        row[key] = v.getTime();
+    }
+    else if (typeof v === "number" || typeof v === "bigint" || typeof v === "string") {
+        row[key] = Number(v);
+    }
+    return row;
+};
+export const mergeData = (key) => (row) => {
+    const data = row[key];
+    if (data !== null && typeof data === "object") {
+        Object.assign(row, data);
+        delete row[key];
+    }
+    return row;
+};

package/dist/endpoints/conversations/storage/memory.d.ts

@@ -0,0 +1,25 @@
+import type { ConversationStorage, ConversationEntity, ConversationItemEntity, ConversationMetadata, ConversationItemInput, ConversationQueryOptions } from "./types";
+export declare class InMemoryStorage implements ConversationStorage {
+    private conversations;
+    private items;
+    constructor(options?: {
+        maxSize?: number;
+    });
+    private estimateSize;
+    private mapItem;
+    createConversation(params: {
+        metadata?: ConversationMetadata;
+        items?: ConversationItemInput[];
+    }): Promise<ConversationEntity>;
+    getConversation(id: string): Promise<ConversationEntity | undefined>;
+    listConversations(params: ConversationQueryOptions): Promise<ConversationEntity[]>;
+    updateConversation(id: string, metadata: ConversationMetadata): Promise<ConversationEntity | undefined>;
+    deleteConversation(id: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+    addItems(conversationId: string, items: ConversationItemInput[]): Promise<ConversationItemEntity[] | undefined>;
+    getItem(conversationId: string, itemId: string): Promise<ConversationItemEntity | undefined>;
+    deleteItem(conversationId: string, itemId: string): Promise<ConversationEntity | undefined>;
+    listItems(conversationId: string, params: ConversationQueryOptions): Promise<ConversationItemEntity[] | undefined>;
+}

package/dist/endpoints/conversations/storage/memory.js

@@ -0,0 +1,200 @@
+import { LRUCache } from "lru-cache";
+import { v7 as uuidv7 } from "uuid";
+export class InMemoryStorage {
+    conversations = new Map();
+    items;
+    constructor(options) {
+        // Default to 256MB
+        const maxSize = options?.maxSize ?? 256 * 1024 * 1024;
+        this.items = new LRUCache({
+            maxSize,
+            sizeCalculation: (items) => Math.max(1, this.estimateSize(items)),
+            noDisposeOnSet: true,
+            dispose: (_value, key) => {
+                this.conversations.delete(key);
+            },
+        });
+    }
+    estimateSize(root) {
+        let total = 0;
+        const stack = [root];
+        while (stack.length > 0) {
+            const obj = stack.pop();
+            if (obj === null || obj === undefined)
+                continue;
+            const t = typeof obj;
+            if (t === "string") {
+                total += obj.length * 2;
+                continue;
+            }
+            if (t !== "object")
+                continue;
+            if (ArrayBuffer.isView(obj)) {
+                total += obj.byteLength;
+                continue;
+            }
+            if (Array.isArray(obj)) {
+                const arr = obj;
+                for (let i = 0, n = arr.length; i < n; i++)
+                    stack.push(arr[i]);
+                continue;
+            }
+            if (obj instanceof Map) {
+                for (const [k, v] of obj) {
+                    stack.push(k);
+                    stack.push(v);
+                }
+                continue;
+            }
+            const rec = obj;
+            for (const k in rec)
+                stack.push(rec[k]);
+        }
+        return total;
+    }
+    mapItem(conversationId, input) {
+        const item = input;
+        item.id ??= uuidv7();
+        item.conversation_id = conversationId;
+        item.created_at = Date.now();
+        return item;
+    }
+    createConversation(params) {
+        const id = uuidv7();
+        const conversation = {
+            id,
+            created_at: Date.now(),
+            metadata: params.metadata ?? null,
+        };
+        const itemMap = new Map();
+        if (params.items) {
+            for (const input of params.items) {
+                const item = this.mapItem(id, input);
+                itemMap.set(item.id, item);
+            }
+        }
+        this.conversations.set(id, conversation);
+        this.items.set(id, itemMap);
+        return Promise.resolve(conversation);
+    }
+    getConversation(id) {
+        // Updates the LRU position
+        if (this.items.get(id) === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(this.conversations.get(id));
+    }
+    listConversations(params) {
+        const { after, order, limit, metadata } = params;
+        if (limit <= 0)
+            return Promise.resolve([]);
+        let results = Array.from(this.conversations.values());
+        // Filter by metadata
+        if (metadata) {
+            results = results.filter((conv) => {
+                if (!conv.metadata)
+                    return false;
+                for (const [key, value] of Object.entries(metadata)) {
+                    if (conv.metadata[key] !== value)
+                        return false;
+                }
+                return true;
+            });
+        }
+        // Sort by created_at (and ID as tiebreaker for cursor consistency)
+        results.sort((a, b) => {
+            if (a.created_at !== b.created_at) {
+                return order === "asc" ? a.created_at - b.created_at : b.created_at - a.created_at;
+            }
+            return order === "asc" ? a.id.localeCompare(b.id) : b.id.localeCompare(a.id);
+        });
+        // Pagination: after
+        if (after) {
+            const index = results.findIndex((conv) => conv.id === after);
+            if (index === -1)
+                return Promise.resolve([]);
+            results = results.slice(index + 1);
+        }
+        return Promise.resolve(results.slice(0, limit));
+    }
+    updateConversation(id, metadata) {
+        // Updates the LRU position
+        if (this.items.get(id) === undefined) {
+            return Promise.resolve(undefined);
+        }
+        const conversation = this.conversations.get(id);
+        if (conversation) {
+            conversation.metadata = metadata ?? null;
+        }
+        return Promise.resolve(conversation);
+    }
+    deleteConversation(id) {
+        // Triggers the dispose handler which cleans up this.conversations
+        const deleted = this.items.delete(id);
+        return Promise.resolve({ id, deleted });
+    }
+    addItems(conversationId, items) {
+        const existing = this.items.get(conversationId);
+        if (!existing) {
+            return Promise.resolve(undefined);
+        }
+        const mappedItems = [];
+        for (const input of items) {
+            const item = this.mapItem(conversationId, input);
+            existing.set(item.id, item);
+            mappedItems.push(item);
+        }
+        // Recalculate the cache size
+        this.items.set(conversationId, existing);
+        return Promise.resolve(mappedItems);
+    }
+    getItem(conversationId, itemId) {
+        return Promise.resolve(this.items.get(conversationId)?.get(itemId));
+    }
+    deleteItem(conversationId, itemId) {
+        const existing = this.items.get(conversationId);
+        if (!existing)
+            return Promise.resolve(undefined);
+        if (existing.delete(itemId)) {
+            // Recalculate the cache size
+            this.items.set(conversationId, existing);
+        }
+        return Promise.resolve(this.conversations.get(conversationId));
+    }
+    listItems(conversationId, params) {
+        const { after, order, limit } = params;
+        const existing = this.items.get(conversationId);
+        if (!existing)
+            return Promise.resolve(undefined);
+        if (limit <= 0)
+            return Promise.resolve([]);
+        // If after is provided but doesn't exist, return empty list
+        if (after && !existing.has(after))
+            return Promise.resolve([]);
+        const out = [];
+        if (order === "asc") {
+            let seen = after === null || after === undefined;
+            for (const item of existing.values()) {
+                if (!seen) {
+                    if (item.id === after)
+                        seen = true;
+                    continue;
+                }
+                out.push(item);
+                if (out.length === limit)
+                    break;
+            }
+            return Promise.resolve(out);
+        }
+        // desc
+        for (const item of existing.values()) {
+            if (after !== null && after !== undefined && item.id === after)
+                break;
+            out.push(item);
+            if (out.length > limit)
+                out.shift(); // bounded buffer
+        }
+        out.reverse();
+        return Promise.resolve(out);
+    }
+}

package/dist/endpoints/conversations/storage/sql.d.ts

@@ -0,0 +1,33 @@
+import type { SqlDialect } from "./dialects/types";
+import type { ConversationStorage, ConversationEntity, ConversationItemEntity, ConversationMetadata, ConversationItemInput, ConversationQueryOptions } from "./types";
+export declare class SqlStorage implements ConversationStorage {
+    readonly dialect: SqlDialect;
+    constructor(options: SqlDialect | {
+        dialect: SqlDialect;
+    });
+    private get executor();
+    private get config();
+    migrate(): Promise<void>;
+    createConversation(params: {
+        metadata?: ConversationMetadata;
+        items?: ConversationItemInput[];
+    }): Promise<ConversationEntity>;
+    getConversation(id: string): Promise<ConversationEntity | undefined>;
+    private getConversationInternal;
+    listConversations(params: ConversationQueryOptions): Promise<ConversationEntity[]>;
+    updateConversation(id: string, metadata: ConversationMetadata): Promise<ConversationEntity | undefined>;
+    deleteConversation(id: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+    addItems(conversationId: string, items: ConversationItemInput[]): Promise<ConversationItemEntity[] | undefined>;
+    private addItemsInternal;
+    getItem(conversationId: string, itemId: string): Promise<ConversationItemEntity | undefined>;
+    deleteItem(conversationId: string, itemId: string): Promise<ConversationEntity | undefined>;
+    listItems(conversationId: string, params: ConversationQueryOptions): Promise<ConversationItemEntity[] | undefined>;
+}
+export * from "./dialects/greptime";
+export * from "./dialects/mysql";
+export * from "./dialects/postgres";
+export * from "./dialects/sqlite";
+export * from "./dialects/types";