sqlql 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,304 @@
+declare namespace planning_d_exports {
+  export { AggregateExpression, AggregateItem, AggregateRequest, AggregateStep, AndPredicate, ColumnRef, ColumnValue, ComparisonOperator, ComparisonPredicate, CteBinding, CteStep, ExplainDecision, ExplainResult, Expression, FilterStep, FromSource, InPredicate, JoinSpec, JoinStep, LiteralValue, MutationIR, NotPredicate, NullPredicate, OrPredicate, OrderByTerm, PlanStep, PlanStepBase, Predicate, ProjectStep, QueryCapabilities, QueryIR, QueryPlan, ResolverContext, ResolverRegistry, Row, RowSet, ScalarValue, ScanRequest, ScanStep, SelectItem, TableResolver, defineTableResolver };
+}
+type ScalarValue = string | number | boolean | null;
+type ComparisonOperator = "=" | "!=" | ">" | ">=" | "<" | "<=";
+interface ColumnRef {
+  table: string;
+  column: string;
+}
+interface LiteralValue {
+  kind: "literal";
+  value: ScalarValue;
+}
+interface ColumnValue {
+  kind: "column";
+  ref: ColumnRef;
+}
+type Expression = ColumnValue | LiteralValue;
+interface ComparisonPredicate {
+  kind: "comparison";
+  operator: ComparisonOperator;
+  left: Expression;
+  right: Expression;
+}
+interface InPredicate {
+  kind: "in";
+  left: Expression;
+  values: ScalarValue[];
+}
+interface NullPredicate {
+  kind: "null_check";
+  expression: Expression;
+  negated: boolean;
+}
+interface AndPredicate {
+  kind: "and";
+  predicates: Predicate[];
+}
+interface OrPredicate {
+  kind: "or";
+  predicates: Predicate[];
+}
+interface NotPredicate {
+  kind: "not";
+  predicate: Predicate;
+}
+type Predicate = ComparisonPredicate | InPredicate | NullPredicate | AndPredicate | OrPredicate | NotPredicate;
+interface SelectItem {
+  expression: Expression;
+  alias?: string;
+}
+interface OrderByTerm {
+  expression: Expression;
+  direction: "asc" | "desc";
+}
+interface JoinSpec {
+  type: "inner" | "left";
+  sourceTable: string;
+  sourceAlias?: string;
+  on: Predicate;
+}
+interface AggregateExpression {
+  function: "count" | "sum" | "avg" | "min" | "max";
+  argument?: Expression;
+  distinct?: boolean;
+}
+interface AggregateItem {
+  alias: string;
+  expression: AggregateExpression;
+}
+interface CteBinding {
+  name: string;
+  query: QueryIR;
+  recursive?: boolean;
+}
+interface FromSource {
+  table: string;
+  alias?: string;
+}
+interface QueryIR {
+  ctes?: CteBinding[];
+  from: FromSource;
+  joins?: JoinSpec[];
+  select: SelectItem[];
+  where?: Predicate;
+  groupBy?: Expression[];
+  aggregates?: AggregateItem[];
+  orderBy?: OrderByTerm[];
+  limit?: number;
+  offset?: number;
+}
+interface MutationIR {
+  type: "insert" | "update" | "delete";
+  table: string;
+}
+interface QueryCapabilities {
+  filterOperators: ComparisonOperator[];
+  filterableColumns: string[];
+  sortableColumns: string[];
+  maxLimit: number;
+  requiresLimit: boolean;
+  supportsOr: boolean;
+  supportsNot: boolean;
+  supportsAggregates: boolean;
+  supportsCtes: boolean;
+  supportsRecursiveCtes: boolean;
+}
+interface ScanRequest {
+  table: string;
+  alias?: string;
+  projection: ColumnRef[];
+  predicate?: Predicate;
+  orderBy?: OrderByTerm[];
+  limit?: number;
+  offset?: number;
+}
+interface AggregateRequest {
+  table: string;
+  alias?: string;
+  predicate?: Predicate;
+  groupBy: Expression[];
+  aggregates: AggregateItem[];
+  orderBy?: OrderByTerm[];
+  limit?: number;
+}
+type Row = Record<string, unknown>;
+interface RowSet {
+  rows: Row[];
+}
+interface ResolverContext {
+  requestId: string;
+  actorId?: string;
+}
+interface TableResolver<TContext extends ResolverContext = ResolverContext> {
+  table: string;
+  capabilities: QueryCapabilities;
+  scan: (request: ScanRequest, context: TContext) => Promise<RowSet>;
+  aggregate?: (request: AggregateRequest, context: TContext) => Promise<RowSet>;
+}
+interface ResolverRegistry<TContext extends ResolverContext = ResolverContext> {
+  getResolver: (table: string) => TableResolver<TContext> | undefined;
+}
+interface PlanStepBase {
+  id: string;
+  dependsOn: string[];
+}
+interface ScanStep extends PlanStepBase {
+  kind: "scan";
+  table: string;
+  resolver: string;
+  request: ScanRequest;
+  pushdown: {
+    predicate: boolean;
+    projection: boolean;
+    orderBy: boolean;
+    limit: boolean;
+  };
+}
+interface FilterStep extends PlanStepBase {
+  kind: "filter";
+  predicate: Predicate;
+}
+interface JoinStep extends PlanStepBase {
+  kind: "join";
+  join: JoinSpec;
+}
+interface AggregateStep extends PlanStepBase {
+  kind: "aggregate";
+  request: AggregateRequest;
+}
+interface ProjectStep extends PlanStepBase {
+  kind: "project";
+  select: SelectItem[];
+}
+interface CteStep extends PlanStepBase {
+  kind: "cte";
+  binding: CteBinding;
+  strategy: "inline" | "materialize";
+}
+type PlanStep = ScanStep | FilterStep | JoinStep | AggregateStep | ProjectStep | CteStep;
+interface QueryPlan {
+  rootStepId: string;
+  steps: PlanStep[];
+}
+interface ExplainDecision {
+  stepId: string;
+  decision: string;
+}
+interface ExplainResult {
+  query: QueryIR;
+  plan: QueryPlan;
+  decisions: ExplainDecision[];
+}
+declare function defineTableResolver<TContext extends ResolverContext = ResolverContext>(resolver: TableResolver<TContext>): TableResolver<TContext>;
+//#endregion
+//#region ../core/src/index.d.ts
+type SqlScalarType = "text" | "integer" | "boolean" | "timestamp";
+type TableColumns = Record<string, SqlScalarType>;
+interface SchemaQueryDefaults {
+  filterable: "all" | string[];
+  sortable: "all" | string[];
+  maxRows: number | null;
+}
+interface TableQueryOverrides {
+  filterable?: "all" | string[];
+  sortable?: "all" | string[];
+  maxRows?: number | null;
+}
+interface TableDefinition {
+  columns: TableColumns;
+  query?: TableQueryOverrides;
+}
+interface SchemaDefinition {
+  defaults?: {
+    query?: Partial<SchemaQueryDefaults>;
+  };
+  tables: Record<string, TableDefinition>;
+}
+declare const DEFAULT_QUERY_BEHAVIOR: SchemaQueryDefaults;
+declare function defineSchema<TSchema extends SchemaDefinition>(schema: TSchema): TSchema;
+declare function getTable(schema: SchemaDefinition, tableName: string): TableDefinition;
+declare function resolveTableQueryBehavior(schema: SchemaDefinition, tableName: string): SchemaQueryDefaults;
+type ScanFilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in";
+interface FilterClauseBase {
+  column: string;
+  op: ScanFilterOperator;
+}
+interface ScalarFilterClause extends FilterClauseBase {
+  op: "eq" | "neq" | "gt" | "gte" | "lt" | "lte";
+  value: unknown;
+}
+interface SetFilterClause extends FilterClauseBase {
+  op: "in";
+  values: unknown[];
+}
+type ScanFilterClause = ScalarFilterClause | SetFilterClause;
+interface ScanOrderBy {
+  column: string;
+  direction: "asc" | "desc";
+}
+interface TableScanRequest {
+  table: string;
+  alias?: string;
+  select: string[];
+  where?: ScanFilterClause[];
+  orderBy?: ScanOrderBy[];
+  limit?: number;
+  offset?: number;
+}
+interface TableLookupRequest {
+  table: string;
+  alias?: string;
+  key: string;
+  values: unknown[];
+  select: string[];
+  where?: ScanFilterClause[];
+}
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+interface TableAggregateMetric {
+  fn: AggregateFunction;
+  column?: string;
+  as: string;
+  distinct?: boolean;
+}
+interface TableAggregateRequest {
+  table: string;
+  alias?: string;
+  where?: ScanFilterClause[];
+  groupBy?: string[];
+  metrics: TableAggregateMetric[];
+  limit?: number;
+}
+type QueryRow = Record<string, unknown>;
+interface TableMethods<TContext = unknown> {
+  scan: (request: TableScanRequest, context: TContext) => Promise<QueryRow[]>;
+  lookup?: (request: TableLookupRequest, context: TContext) => Promise<QueryRow[]>;
+  aggregate?: (request: TableAggregateRequest, context: TContext) => Promise<QueryRow[]>;
+}
+type TableMethodsMap<TContext = unknown> = Record<string, TableMethods<TContext>>;
+declare function defineTableMethods<TContext, TMethods extends TableMethodsMap<TContext>>(methods: TMethods): TMethods;
+interface SqlDdlOptions {
+  ifNotExists?: boolean;
+}
+declare function toSqlDDL(schema: SchemaDefinition, options?: SqlDdlOptions): string;
+//#endregion
+//#region ../sql/src/index.d.ts
+interface SqlQuery {
+  text: string;
+}
+interface PlannedQuery {
+  source: string;
+  selectAll: boolean;
+}
+interface QueryInput<TContext> {
+  schema: SchemaDefinition;
+  methods: TableMethodsMap<TContext>;
+  context: TContext;
+  sql: string;
+}
+declare function parseSql(query: SqlQuery, schema: SchemaDefinition): PlannedQuery;
+declare function query<TContext>(input: QueryInput<TContext>): Promise<QueryRow[]>;
+//#endregion
+export { AggregateFunction, DEFAULT_QUERY_BEHAVIOR, FilterClauseBase, PlannedQuery, QueryInput, QueryRow, ScalarFilterClause, ScanFilterClause, ScanFilterOperator, ScanOrderBy, SchemaDefinition, SchemaQueryDefaults, SetFilterClause, SqlDdlOptions, SqlQuery, SqlScalarType, TableAggregateMetric, TableAggregateRequest, TableColumns, TableDefinition, TableLookupRequest, TableMethods, TableMethodsMap, TableQueryOverrides, TableScanRequest, defineSchema, defineTableMethods, getTable, parseSql, planning_d_exports as planning, query, resolveTableQueryBehavior, toSqlDDL };
+//# sourceMappingURL=index.d.mts.map