exoagent 0.0.1 → 0.0.3

package/dist/rpc-toolset.d.ts

@@ -0,0 +1,34 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { RpcTarget } from '../packages/capnweb/dist';
+declare const toolMetadataKey: unique symbol;
+type ToolMetadata = {
+    [toolMetadataKey]?: {
+        runtimeValidationEnabled?: boolean;
+    };
+};
+export declare const setToolMetadata: (target: (...args: any[]) => unknown, metadata: ToolMetadata[typeof toolMetadataKey]) => void;
+declare function toolDef(): <This, Return>(target: (this: This) => Return, context: ClassMethodDecoratorContext<This, (this: This) => Return>) => (this: This) => Return;
+declare function toolDef<TInput>(inputSchema: StandardSchemaV1<TInput, TInput>): <This, Return>(target: (this: This, arg: TInput) => Return, context: ClassMethodDecoratorContext<This, (this: This, arg: TInput) => Return>) => (this: This, arg: TInput) => Return;
+declare function toolUnsafeNoValidation(): <This, Return>(target: (this: This, ...args: any[]) => Return, context: ClassMethodDecoratorContext<This, (...unknown: any[]) => Return>) => any;
+declare const callbackMetadataKey: unique symbol;
+export type ToolCallback<T extends (arg: any) => unknown> = T | {
+    [callbackMetadataKey]: {
+        callback: T;
+    };
+};
+type Fn = ToolCallback<(arg: any) => any>;
+declare function callbackTool(): <This, Return>(target: (this: This, arg: Fn) => Return, context: ClassMethodDecoratorContext<This, (this: This, arg: Fn) => Return>) => (this: This, arg: Fn) => Return;
+declare const unwrapCallback: <A, V>(toolCallback: ToolCallback<(arg: A) => V>, returnSchema: StandardSchemaV1<V, V> | ((arg: unknown) => arg is V)) => <R>(arg: A, then: (result: V) => R, opts?: {
+    catch?: (error: unknown) => R;
+    finally?: () => void;
+}) => R;
+export type ToolAnnotation = typeof toolDef & {
+    callback: typeof callbackTool;
+    unwrap: typeof unwrapCallback;
+    unsafeNoValidation: typeof toolUnsafeNoValidation;
+};
+export declare const tool: ToolAnnotation;
+export declare class RpcToolset extends RpcTarget {
+    constructor();
+}
+export {};

package/dist/sql/builder.d.ts

@@ -0,0 +1,127 @@
+import { CompiledQuery, Dialect } from 'kysely';
+import { ToolCallback, RpcToolset } from '../rpc-toolset';
+import { SqlExpressionIn, ColumnReferenceExpression, OrderByValue, SqlExpression } from './expression';
+import { RawSql } from './sql';
+type RowLikeRaw = {
+    [key: string]: SqlExpression;
+};
+type RowLikeRawIn = {
+    [key: string]: SqlExpressionIn;
+};
+type RowLike = RowLikeRaw | TableBase;
+type RowLikeIn = RowLikeRawIn | RowLike;
+type AsRowLike<R extends RowLikeIn> = R extends TableBase ? R : {
+    [key in keyof R]: R[key] extends SqlExpression ? R[key] : SqlExpression;
+};
+type NamespacedExpression<A, R> = (arg: A) => R;
+type FromItem<N extends string, F extends RowLike> = {
+    alias: N;
+    toRowLike: () => F;
+    compile: (opts?: {
+        isSubquery?: boolean;
+    }) => RawSql;
+    onExpression?: SqlExpression;
+};
+export declare const isFromItem: (value: unknown) => value is FromItem<string, RowLike>;
+type TableNamespace = {
+    [key: string]: RowLike;
+};
+type OrderByItem<TN extends TableNamespace> = NamespacedExpression<TN, SqlExpression | SqlExpression[] | OrderByValue | OrderByValue[] | (SqlExpression | OrderByValue)[]>;
+type Tables<TN extends TableNamespace> = {
+    [k in keyof TN & string]: {
+        fromItem: FromItem<k, TN[k]>;
+        joinType: 'inner' | 'left' | null;
+        on?: SqlExpression;
+        isLateral: boolean;
+    };
+};
+type QueryBuilderParams<N extends string, TN extends TableNamespace, S extends RowLike> = {
+    db: Database;
+    alias: N;
+    tables: Tables<TN>;
+    selectRowLike: S;
+    whereExpression?: SqlExpression;
+    orderByExpressions?: OrderByValue[];
+    limit?: number;
+    offset?: number;
+    rawTable: TableClass<N> | undefined;
+};
+declare class QueryBuilder<N extends string, TN extends TableNamespace, S extends RowLike> extends RpcToolset implements FromItem<N, S> {
+    #private;
+    readonly alias: N;
+    private selectRowLike;
+    private tables;
+    private whereExpression?;
+    private orderByExpressions?;
+    private arg;
+    private rawTable;
+    constructor(params: QueryBuilderParams<N, TN, S>);
+    select<S2 extends RowLikeIn>(select: ToolCallback<(arg: TN) => S2>): QueryBuilder<N, TN, AsRowLike<S2>>;
+    where(where: ToolCallback<(arg: TN) => SqlExpressionIn>): QueryBuilder<N, TN, S>;
+    orderBy(orderBy: ToolCallback<OrderByItem<TN>>): QueryBuilder<N, TN, S>;
+    limit(limit: number): QueryBuilder<N, TN, S>;
+    offset(offset: number): QueryBuilder<N, TN, S>;
+    join<N2 extends string, F2 extends TableClass<N2>>(fromItem: F2 | NamespacedExpression<TN, F2>, on?: NamespacedExpression<TN & {
+        [k in N2]: InstanceType<F2>;
+    }, SqlExpressionIn>): QueryBuilder<N, TN & {
+        [k in N2]: InstanceType<F2>;
+    }, S>;
+    join<N2 extends string, F2 extends RowLike>(fromItem: FromItem<N2, F2> | NamespacedExpression<TN, FromItem<N2, F2>>, on?: NamespacedExpression<TN & {
+        [k in N2]: F2;
+    }, SqlExpressionIn>): QueryBuilder<N, TN & {
+        [k in N2]: F2;
+    }, S>;
+    execute(): Promise<{
+        results: {
+            [key in keyof S]: unknown;
+        }[];
+        sql?: string;
+        parameters?: readonly unknown[];
+    }>;
+    private paramsForCopy;
+    toRowLike: () => S;
+    compile: (opts?: {
+        isSubquery?: boolean;
+    }) => import('kysely').RawBuilder<unknown>;
+}
+declare class TableBase extends RpcToolset {
+    opts?: {
+        remapColumns?: boolean;
+    };
+    column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
+}
+export type TableClass<N extends string = string> = {
+    new (opts?: {
+        remapColumns?: boolean;
+    }): TableBase;
+    as: <T extends TableClass, N2 extends string>(this: T, alias: N2) => Omit<T, keyof TableClass> & TableClass<N2> & {
+        new (): InstanceType<T>;
+    };
+    toRowLike: <T extends TableClass>(this: T, opts?: {
+        remapColumns?: boolean;
+    }) => InstanceType<T>;
+    from: <T extends TableClass>(this: T) => QueryBuilder<N, {
+        [k in N]: InstanceType<T>;
+    }, InstanceType<T>>;
+    on: <T extends TableClass>(this: T, on: NamespacedExpression<InstanceType<T>, SqlExpression>) => T;
+    compile: () => RawSql;
+    alias: N;
+    tableName: string;
+    onExpression?: SqlExpression;
+};
+export declare class Database {
+    private dialect;
+    private opts?;
+    private kysely?;
+    constructor(dialect: Dialect, opts?: {
+        logQuery?: (raw: CompiledQuery) => void;
+        returnExecutedQuery?: boolean;
+    } | undefined);
+    execute(query: RawSql): Promise<{
+        results: unknown[];
+        sql?: string;
+        parameters?: readonly unknown[];
+    }>;
+    Table<N extends string>(name: N): TableClass<N>;
+}
+export {};

package/dist/sql/expression.d.ts

@@ -0,0 +1,69 @@
+import { RawSql } from './sql';
+import { RpcToolset } from '../rpc-toolset';
+type LiteralValue = number | string | boolean | null;
+export type SqlExpressionIn = LiteralValue | SqlExpression;
+export declare const asSqlExpression: (value: LiteralValue | SqlExpression) => SqlExpression;
+export declare const isSqlExpressionIn: (value: unknown) => value is SqlExpressionIn;
+export declare class SqlExpression extends RpcToolset {
+    precedence: number;
+    constructor(precedence?: number);
+    compile: () => RawSql;
+    or(expr: SqlExpression): BinaryExpression;
+    and(expr: SqlExpression): BinaryExpression;
+    not(): UnaryExpression;
+    isNull(): UnaryExpression;
+    isNotNull(): UnaryExpression;
+    '<'(expr: SqlExpression | number | string): BinaryExpression;
+    '<='(expr: SqlExpression | number | string): BinaryExpression;
+    '>'(expr: SqlExpression | number | string): BinaryExpression;
+    '>='(expr: SqlExpression | number | string): BinaryExpression;
+    '='(expr: SqlExpressionIn): BinaryExpression;
+    '<>'(expr: SqlExpressionIn): BinaryExpression;
+    '!='(expr: SqlExpressionIn): BinaryExpression;
+    'LIKE'(expr: SqlExpression | string): BinaryExpression;
+    'NOT LIKE'(expr: SqlExpression | string): BinaryExpression;
+    '+'(expr: SqlExpression | number | string): BinaryExpression;
+    '-'(expr: SqlExpression | number | string): BinaryExpression;
+    '*'(expr: SqlExpression | number | string): BinaryExpression;
+    '/'(expr: SqlExpression | number | string): BinaryExpression;
+    '%'(expr: SqlExpression | number | string): BinaryExpression;
+    asc(): OrderByValue;
+    desc(): OrderByValue;
+}
+export declare class BinaryExpression extends SqlExpression {
+    private readonly left;
+    private readonly right;
+    private readonly operator;
+    constructor(left: SqlExpression, right: SqlExpression, operator: RawSql, precedence?: number);
+    compile: () => import('kysely').RawBuilder<unknown>;
+}
+export declare class UnaryExpression extends SqlExpression {
+    private readonly operand;
+    private readonly operator;
+    private readonly placement;
+    constructor(operand: SqlExpression, operator: RawSql, placement: 'prefix' | 'postfix', precedence?: number);
+    compile: () => import('kysely').RawBuilder<unknown>;
+}
+export declare class ColumnReferenceExpression extends SqlExpression {
+    readonly alias: string;
+    readonly column: string;
+    constructor(alias: string, column: string);
+    compile: () => import('kysely').RawBuilder<unknown>;
+}
+export declare class UnboundColumnReferenceExpression extends ColumnReferenceExpression {
+    readonly alias: string;
+    readonly column: string;
+    constructor(alias: string, column: string);
+    compile: () => never;
+}
+export declare class LiteralExpression extends SqlExpression {
+    private readonly value;
+    constructor(value: LiteralValue);
+    compile: () => import('kysely').RawBuilder<unknown>;
+}
+export declare class OrderByValue {
+    value: SqlExpression;
+    direction?: RawSql | undefined;
+    constructor(value: SqlExpression, direction?: RawSql | undefined);
+}
+export {};

package/dist/sql/sql.d.ts

@@ -0,0 +1,4 @@
+import { RawBuilder } from 'kysely';
+export declare const sql: import('kysely').Sql;
+export type RawSql = RawBuilder<unknown>;
+export declare const buildSql: (parts: unknown[], separator?: RawSql) => RawBuilder<unknown>;

package/dist/sql/test-helpers.d.ts

@@ -0,0 +1,9 @@
+import { Dialect } from 'kysely';
+import { RawSql } from './sql';
+import { PGliteDialect } from 'kysely-pglite-dialect';
+export declare const pgliteDialect: PGliteDialect;
+export declare const dummyDialect: Dialect;
+export declare const compiledQuery: (query: RawSql) => {
+    sql: string;
+    parameters: readonly unknown[];
+};

package/dist/sql.d.ts

@@ -0,0 +1,2 @@
+export { Database } from './sql/builder.js';
+export type { TableClass } from './sql/builder.js';