exoagent 0.0.11 → 0.0.13

package/dist/rpc-toolset-test-helpers.d.mts

@@ -1,254 +0,0 @@
-import * as kysely0 from "kysely";
-import { CompiledQuery, Dialect, RawBuilder } from "kysely";
-
-//#region packages/capnweb/dist/index.d.ts
-
-declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
-interface RpcTargetBranded {
-  [__RPC_TARGET_BRAND]: never;
-}
-
-// Types that can be used through `Stub`s
-
-/**
- * Classes which are intended to be passed by reference and called over RPC must extend
- * `RpcTarget`. A class which does not extend `RpcTarget` (and which doesn't have built-in support
- * from the RPC system) cannot be passed in an RPC message at all; an exception will be thrown.
- *
- * Note that on Cloudflare Workers, this `RpcTarget` is an alias for the one exported from the
- * "cloudflare:workers" module, so they can be used interchangably.
- */
-interface RpcTarget extends RpcTargetBranded {}
-declare const RpcTarget: {
-  new (): RpcTarget;
-};
-/**
- * Empty interface used as default type parameter for sessions where the other side doesn't
- * necessarily export a main interface.
- */
-//#endregion
-//#region src/rpc-toolset.d.ts
-
-declare const callbackMetadataKey: unique symbol;
-type ToolCallback<T extends (arg: any) => unknown> = T | {
-  [callbackMetadataKey]: {
-    callback: T;
-  };
-};
-declare class RpcToolset extends RpcTarget {
-  constructor();
-}
-//#endregion
-//#region src/sql/sql.d.ts
-type RawSql = RawBuilder<unknown>;
-//#endregion
-//#region src/sql/expression.d.ts
-type LiteralValue = number | string | boolean | null;
-type SqlExpressionIn = LiteralValue | SqlExpression;
-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;
-}
-declare class BinaryExpression extends SqlExpression {
-  private readonly left;
-  private readonly right;
-  private readonly operator;
-  constructor(left: SqlExpression, right: SqlExpression, operator: RawSql, precedence?: number);
-  compile: () => kysely0.RawBuilder<unknown>;
-}
-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: () => kysely0.RawBuilder<unknown>;
-}
-declare class ColumnReferenceExpression extends SqlExpression {
-  readonly alias: string;
-  readonly column: string;
-  constructor(alias: string, column: string);
-  compile: () => kysely0.RawBuilder<unknown>;
-}
-declare class OrderByValue {
-  value: SqlExpression;
-  direction?: RawSql | undefined;
-  constructor(value: SqlExpression, direction?: RawSql | undefined);
-}
-//#endregion
-//#region src/sql/builder.d.ts
-type RowLikeRaw = {
-  [key: string]: SqlExpression;
-};
-type RowLikeRawIn = {
-  [key: string]: SqlExpressionIn;
-};
-type RowLike = RowLikeRaw | TableBase;
-type RowLikeIn = RowLikeRawIn | RowLike;
-type AsRowLike<R$1 extends RowLikeIn> = R$1 extends TableBase ? R$1 : { [key in keyof R$1]: R$1[key] extends SqlExpression ? R$1[key] : SqlExpression };
-type NamespacedExpression<A, R$1> = (arg: A) => R$1;
-type FromItem<N extends string, F extends RowLike> = {
-  alias: N;
-  toRowLike: () => F;
-  compile: (opts?: {
-    isSubquery?: boolean;
-  }) => RawSql;
-  onExpression?: SqlExpression;
-};
-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;
-  }) => kysely0.RawBuilder<unknown>;
-}
-declare class TableBase extends RpcToolset {
-  opts?: {
-    remapColumns?: boolean;
-  };
-  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
-}
-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;
-};
-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>;
-}
-//#endregion
-//#region src/rpc-toolset-test-helpers.d.ts
-declare class TestToolset extends RpcToolset {
-  add(input: {
-    a: number;
-    b: number;
-  }): Promise<number>;
-  toolset2(): Promise<TestToolset2>;
-  userForId({
-    id
-  }: {
-    id: string;
-  }): Promise<typeof User>;
-}
-declare class TestToolset2 extends RpcToolset {
-  subtract(input: {
-    a: number;
-    b: number;
-  }): Promise<number>;
-}
-declare const User_base: Omit<TableClass<"users">, keyof TableClass<string>> & TableClass<"user"> & (new () => {
-  opts?: {
-    remapColumns?: boolean;
-  };
-  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
-  __RPC_TARGET_BRAND: never;
-});
-declare class User extends User_base {
-  id: ColumnReferenceExpression;
-  name: ColumnReferenceExpression;
-  email: ColumnReferenceExpression;
-  age: ColumnReferenceExpression;
-  posts(): typeof Post;
-}
-declare const Post_base: Omit<TableClass<"posts">, keyof TableClass<string>> & TableClass<"post"> & (new () => {
-  opts?: {
-    remapColumns?: boolean;
-  };
-  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
-  __RPC_TARGET_BRAND: never;
-});
-declare class Post extends Post_base {
-  id: ColumnReferenceExpression;
-  userId: ColumnReferenceExpression;
-  title: ColumnReferenceExpression;
-  content: ColumnReferenceExpression;
-}
-//#endregion
-export { Post, TestToolset, TestToolset2, User };