@hebo-ai/gateway 0.9.0 → 0.9.2

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

@@ -1,42 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-/**
- * 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

@@ -1,80 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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

@@ -1,33 +0,0 @@
-import type { ConversationStorage, ConversationEntity, ConversationItemEntity, ConversationMetadata, ConversationItemInput, ConversationQueryOptions } from "./types";
-import type { SqlDialect } from "./dialects/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";