@prisma-next/mongo-query-ast 0.0.1

package/src/exports/index.ts

@@ -0,0 +1,97 @@
+export type { AggRecordArgs, MongoAggExpr, MongoAggSwitchBranch } from '../aggregation-expressions';
+export {
+  isExprArray,
+  isRecordArgs,
+  MongoAggAccumulator,
+  MongoAggArrayFilter,
+  MongoAggCond,
+  MongoAggFieldRef,
+  MongoAggLet,
+  MongoAggLiteral,
+  MongoAggMap,
+  MongoAggMergeObjects,
+  MongoAggOperator,
+  MongoAggReduce,
+  MongoAggSwitch,
+} from '../aggregation-expressions';
+export type { AnyMongoCommand, MongoUpdateSpec } from '../commands';
+export {
+  AggregateCommand,
+  DeleteManyCommand,
+  DeleteOneCommand,
+  FindOneAndDeleteCommand,
+  FindOneAndUpdateCommand,
+  InsertManyCommand,
+  InsertOneCommand,
+  UpdateManyCommand,
+  UpdateOneCommand,
+} from '../commands';
+export type { MongoFilterExpr } from '../filter-expressions';
+export {
+  MongoAndExpr,
+  MongoExistsExpr,
+  MongoExprFilter,
+  MongoFieldFilter,
+  MongoNotExpr,
+  MongoOrExpr,
+} from '../filter-expressions';
+export type { MongoQueryPlan } from '../query-plan';
+export type { RawMongoCommand } from '../raw-commands';
+export {
+  RawAggregateCommand,
+  RawDeleteManyCommand,
+  RawDeleteOneCommand,
+  RawFindOneAndDeleteCommand,
+  RawFindOneAndUpdateCommand,
+  RawInsertManyCommand,
+  RawInsertOneCommand,
+  RawUpdateManyCommand,
+  RawUpdateOneCommand,
+} from '../raw-commands';
+export type {
+  MongoDensifyRange,
+  MongoFillOutput,
+  MongoGroupId,
+  MongoPipelineStage,
+  MongoProjectionValue,
+  MongoUpdatePipelineStage,
+  MongoWindowField,
+} from '../stages';
+export {
+  MongoAddFieldsStage,
+  MongoBucketAutoStage,
+  MongoBucketStage,
+  MongoCountStage,
+  MongoDensifyStage,
+  MongoFacetStage,
+  MongoFillStage,
+  MongoGeoNearStage,
+  MongoGraphLookupStage,
+  MongoGroupStage,
+  MongoLimitStage,
+  MongoLookupStage,
+  MongoMatchStage,
+  MongoMergeStage,
+  MongoOutStage,
+  MongoProjectStage,
+  MongoRedactStage,
+  MongoReplaceRootStage,
+  MongoSampleStage,
+  MongoSearchMetaStage,
+  MongoSearchStage,
+  MongoSetWindowFieldsStage,
+  MongoSkipStage,
+  MongoSortByCountStage,
+  MongoSortStage,
+  MongoUnionWithStage,
+  MongoUnwindStage,
+  MongoVectorSearchStage,
+} from '../stages';
+export type {
+  MongoAggExprRewriter,
+  MongoAggExprVisitor,
+  MongoFilterRewriter,
+  MongoFilterVisitor,
+  MongoStageRewriterContext,
+  MongoStageVisitor,
+} from '../visitors';

package/src/filter-expressions.ts

@@ -0,0 +1,210 @@
+import type { MongoValue } from '@prisma-next/mongo-value';
+import type { MongoAggExpr } from './aggregation-expressions';
+import { MongoAstNode } from './ast-node';
+import type { MongoFilterRewriter, MongoFilterVisitor } from './visitors';
+
+abstract class MongoFilterExpression extends MongoAstNode {
+  abstract accept<R>(visitor: MongoFilterVisitor<R>): R;
+  abstract rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+
+  not(this: MongoFilterExpr): MongoNotExpr {
+    return new MongoNotExpr(this);
+  }
+}
+
+export class MongoFieldFilter extends MongoFilterExpression {
+  readonly kind = 'field' as const;
+  readonly field: string;
+  readonly op: string;
+  readonly value: MongoValue;
+
+  constructor(field: string, op: string, value: MongoValue) {
+    super();
+    this.field = field;
+    this.op = op;
+    this.value = value;
+    this.freeze();
+  }
+
+  static of(field: string, op: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, op, value);
+  }
+
+  static eq(field: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$eq', value);
+  }
+
+  static neq(field: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$ne', value);
+  }
+
+  static gt(field: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$gt', value);
+  }
+
+  static lt(field: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$lt', value);
+  }
+
+  static gte(field: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$gte', value);
+  }
+
+  static lte(field: string, value: MongoValue): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$lte', value);
+  }
+
+  static in(field: string, values: ReadonlyArray<MongoValue>): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$in', values);
+  }
+
+  static isNull(field: string): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$eq', null);
+  }
+
+  static isNotNull(field: string): MongoFieldFilter {
+    return new MongoFieldFilter(field, '$ne', null);
+  }
+
+  accept<R>(visitor: MongoFilterVisitor<R>): R {
+    return visitor.field(this);
+  }
+
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr {
+    return rewriter.field ? rewriter.field(this) : this;
+  }
+}
+
+export class MongoAndExpr extends MongoFilterExpression {
+  readonly kind = 'and' as const;
+  readonly exprs: ReadonlyArray<MongoFilterExpr>;
+
+  constructor(exprs: ReadonlyArray<MongoFilterExpr>) {
+    super();
+    if (exprs.length === 0) {
+      throw new Error('$and requires at least one expression');
+    }
+    this.exprs = Object.freeze([...exprs]);
+    this.freeze();
+  }
+
+  static of(exprs: ReadonlyArray<MongoFilterExpr>): MongoAndExpr {
+    return new MongoAndExpr(exprs);
+  }
+
+  accept<R>(visitor: MongoFilterVisitor<R>): R {
+    return visitor.and(this);
+  }
+
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr {
+    const rewritten = new MongoAndExpr(this.exprs.map((e) => e.rewrite(rewriter)));
+    return rewriter.and ? rewriter.and(rewritten) : rewritten;
+  }
+}
+
+export class MongoOrExpr extends MongoFilterExpression {
+  readonly kind = 'or' as const;
+  readonly exprs: ReadonlyArray<MongoFilterExpr>;
+
+  constructor(exprs: ReadonlyArray<MongoFilterExpr>) {
+    super();
+    if (exprs.length === 0) {
+      throw new Error('$or requires at least one expression');
+    }
+    this.exprs = Object.freeze([...exprs]);
+    this.freeze();
+  }
+
+  static of(exprs: ReadonlyArray<MongoFilterExpr>): MongoOrExpr {
+    return new MongoOrExpr(exprs);
+  }
+
+  accept<R>(visitor: MongoFilterVisitor<R>): R {
+    return visitor.or(this);
+  }
+
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr {
+    const rewritten = new MongoOrExpr(this.exprs.map((e) => e.rewrite(rewriter)));
+    return rewriter.or ? rewriter.or(rewritten) : rewritten;
+  }
+}
+
+export class MongoNotExpr extends MongoFilterExpression {
+  readonly kind = 'not' as const;
+  readonly expr: MongoFilterExpr;
+
+  constructor(expr: MongoFilterExpr) {
+    super();
+    this.expr = expr;
+    this.freeze();
+  }
+
+  accept<R>(visitor: MongoFilterVisitor<R>): R {
+    return visitor.not(this);
+  }
+
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr {
+    const rewritten = new MongoNotExpr(this.expr.rewrite(rewriter));
+    return rewriter.not ? rewriter.not(rewritten) : rewritten;
+  }
+}
+
+export class MongoExistsExpr extends MongoFilterExpression {
+  readonly kind = 'exists' as const;
+  readonly field: string;
+  readonly exists: boolean;
+
+  constructor(field: string, exists: boolean) {
+    super();
+    this.field = field;
+    this.exists = exists;
+    this.freeze();
+  }
+
+  static exists(field: string): MongoExistsExpr {
+    return new MongoExistsExpr(field, true);
+  }
+
+  static notExists(field: string): MongoExistsExpr {
+    return new MongoExistsExpr(field, false);
+  }
+
+  accept<R>(visitor: MongoFilterVisitor<R>): R {
+    return visitor.exists(this);
+  }
+
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr {
+    return rewriter.exists ? rewriter.exists(this) : this;
+  }
+}
+
+export class MongoExprFilter extends MongoFilterExpression {
+  readonly kind = 'expr' as const;
+  readonly aggExpr: MongoAggExpr;
+
+  constructor(aggExpr: MongoAggExpr) {
+    super();
+    this.aggExpr = aggExpr;
+    this.freeze();
+  }
+
+  static of(aggExpr: MongoAggExpr): MongoExprFilter {
+    return new MongoExprFilter(aggExpr);
+  }
+
+  accept<R>(visitor: MongoFilterVisitor<R>): R {
+    return visitor.expr(this);
+  }
+
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr {
+    return rewriter.expr ? rewriter.expr(this) : this;
+  }
+}
+
+export type MongoFilterExpr =
+  | MongoFieldFilter
+  | MongoAndExpr
+  | MongoOrExpr
+  | MongoNotExpr
+  | MongoExistsExpr
+  | MongoExprFilter;

package/src/query-plan.ts

@@ -0,0 +1,11 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
+import type { AnyMongoCommand } from './commands';
+
+declare const __mongoQueryPlanRow: unique symbol;
+
+export interface MongoQueryPlan<Row = unknown> {
+  readonly collection: string;
+  readonly command: AnyMongoCommand;
+  readonly meta: PlanMeta;
+  readonly [__mongoQueryPlanRow]?: Row;
+}

package/src/raw-commands.ts

@@ -0,0 +1,143 @@
+import type { Document } from '@prisma-next/mongo-value';
+import { MongoAstNode } from './ast-node';
+
+export class RawAggregateCommand extends MongoAstNode {
+  readonly kind = 'rawAggregate' as const;
+  readonly collection: string;
+  readonly pipeline: ReadonlyArray<Document>;
+
+  constructor(collection: string, pipeline: ReadonlyArray<Document>) {
+    super();
+    this.collection = collection;
+    this.pipeline = pipeline;
+    this.freeze();
+  }
+}
+
+export class RawInsertOneCommand extends MongoAstNode {
+  readonly kind = 'rawInsertOne' as const;
+  readonly collection: string;
+  readonly document: Document;
+
+  constructor(collection: string, document: Document) {
+    super();
+    this.collection = collection;
+    this.document = document;
+    this.freeze();
+  }
+}
+
+export class RawInsertManyCommand extends MongoAstNode {
+  readonly kind = 'rawInsertMany' as const;
+  readonly collection: string;
+  readonly documents: ReadonlyArray<Document>;
+
+  constructor(collection: string, documents: ReadonlyArray<Document>) {
+    super();
+    this.collection = collection;
+    this.documents = documents;
+    this.freeze();
+  }
+}
+
+export class RawUpdateOneCommand extends MongoAstNode {
+  readonly kind = 'rawUpdateOne' as const;
+  readonly collection: string;
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>) {
+    super();
+    this.collection = collection;
+    this.filter = filter;
+    this.update = update;
+    this.freeze();
+  }
+}
+
+export class RawUpdateManyCommand extends MongoAstNode {
+  readonly kind = 'rawUpdateMany' as const;
+  readonly collection: string;
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>) {
+    super();
+    this.collection = collection;
+    this.filter = filter;
+    this.update = update;
+    this.freeze();
+  }
+}
+
+export class RawDeleteOneCommand extends MongoAstNode {
+  readonly kind = 'rawDeleteOne' as const;
+  readonly collection: string;
+  readonly filter: Document;
+
+  constructor(collection: string, filter: Document) {
+    super();
+    this.collection = collection;
+    this.filter = filter;
+    this.freeze();
+  }
+}
+
+export class RawDeleteManyCommand extends MongoAstNode {
+  readonly kind = 'rawDeleteMany' as const;
+  readonly collection: string;
+  readonly filter: Document;
+
+  constructor(collection: string, filter: Document) {
+    super();
+    this.collection = collection;
+    this.filter = filter;
+    this.freeze();
+  }
+}
+
+export class RawFindOneAndUpdateCommand extends MongoAstNode {
+  readonly kind = 'rawFindOneAndUpdate' as const;
+  readonly collection: string;
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  readonly upsert: boolean;
+
+  constructor(
+    collection: string,
+    filter: Document,
+    update: Document | ReadonlyArray<Document>,
+    upsert: boolean,
+  ) {
+    super();
+    this.collection = collection;
+    this.filter = filter;
+    this.update = update;
+    this.upsert = upsert;
+    this.freeze();
+  }
+}
+
+export class RawFindOneAndDeleteCommand extends MongoAstNode {
+  readonly kind = 'rawFindOneAndDelete' as const;
+  readonly collection: string;
+  readonly filter: Document;
+
+  constructor(collection: string, filter: Document) {
+    super();
+    this.collection = collection;
+    this.filter = filter;
+    this.freeze();
+  }
+}
+
+export type RawMongoCommand =
+  | RawAggregateCommand
+  | RawInsertOneCommand
+  | RawInsertManyCommand
+  | RawUpdateOneCommand
+  | RawUpdateManyCommand
+  | RawDeleteOneCommand
+  | RawDeleteManyCommand
+  | RawFindOneAndUpdateCommand
+  | RawFindOneAndDeleteCommand;