@mongorm/orm 0.1.0 → 0.1.1-beta.2

package/src/query/many-query.ts

@@ -1,338 +0,0 @@
-import { ObjectId, type Collection, type Filter as MongoFilter, type Sort } from 'mongodb';
-
-import type { Db } from '../connection/database.js';
-import type { SchemaRelationMap, SchemaShape, ScopeDefinitions } from '../schema/index.js';
-import { CursorQueryError, EstimatedCountError, InvalidQueryError } from '../validation/errors.js';
-import { ModelCursor } from './cursor.js';
-import {
-  createCursorFilter,
-  PopulationExecutor,
-  projectionFor,
-  SoftDeleteState,
-} from './runtime.js';
-import type {
-  CursorMethod,
-  HiddenDocumentKey,
-  ModelFilter,
-  ModelSort,
-  ModelDocument,
-  PopulateSpecs,
-  PopulatedResult,
-  PopulationMode,
-  ScopeName,
-  SelectedDocument,
-  SelectableKey,
-  StoredDocument,
-  VisibleDocument,
-} from './types.js';
-export type {
-  ModelFilter,
-  ModelSort,
-  PopulateSpec,
-  PopulateSpecs,
-  PopulatedResult,
-  SelectedDocument,
-  SelectableKey,
-  StoredDocument,
-  VisibleDocument,
-} from './types.js';
-
-export { ModelCursor } from './cursor.js';
-
-/** A typed, awaitable MongoDB find query. */
-export class ModelQuery<
-  Shape extends SchemaShape,
-  Result extends object = VisibleDocument<Shape>,
-  CursorReady extends boolean = true,
-  Relations extends SchemaRelationMap = {},
-  Scopes extends ScopeDefinitions = {},
-  Mode extends PopulationMode = 'none',
-  SoftDelete extends boolean = false,
-> implements PromiseLike<Result[]> {
-  declare readonly deleted: SoftDelete extends true ? (mode: 'only' | 'include') => this : never;
-  private sortSpec: ModelSort<Shape> | undefined;
-  private skipCount: number | undefined;
-  private limitCount: number | undefined;
-  private selectedFields: readonly string[] | undefined;
-  private shownFields: readonly string[] = [];
-  private populateSpecs: PopulateSpecs<Relations> = [];
-  private populationMode: PopulationMode = 'none';
-  private readonly softDelete: SoftDeleteState<Shape>;
-  private readonly population: PopulationExecutor<Relations>;
-  readonly cursor = ((after?: ObjectId) => this.createCursor(after)) as CursorMethod<
-    Shape,
-    Result,
-    CursorReady
-  >;
-
-  constructor(
-    private readonly collection: Collection<StoredDocument<Shape>>,
-    private readonly filterSpec: ModelFilter<Shape>,
-    private readonly fields: readonly string[],
-    private readonly hiddenFields: readonly string[],
-    private readonly db: Db,
-    private readonly relations: Relations,
-    private readonly scopes: Scopes,
-    private readonly softdeleteEnabled: boolean,
-  ) {
-    this.softDelete = new SoftDeleteState(softdeleteEnabled);
-    this.population = new PopulationExecutor(db, relations);
-    if (softdeleteEnabled) {
-      Object.defineProperties(this, {
-        deleted: {
-          configurable: false,
-          enumerable: false,
-          value: (mode: 'only' | 'include') => this.deletedMode(mode),
-        },
-      });
-    }
-  }
-
-  /** Include both active and soft-deleted documents in this query. */
-  private deletedMode(mode: 'only' | 'include'): this {
-    this.softDelete.deleted(mode);
-    return this;
-  }
-
-  private effectiveFilter(): ModelFilter<Shape> {
-    return this.softDelete.effectiveFilter(this.filterSpec);
-  }
-
-  /** Sort results by one or more schema fields. */
-  sort(
-    spec: ModelSort<Shape>,
-  ): ModelQuery<Shape, Result, false, Relations, Scopes, Mode, SoftDelete> {
-    this.sortSpec = spec;
-    return this as unknown as ModelQuery<Shape, Result, false, Relations, Scopes, Mode, SoftDelete>;
-  }
-
-  /** Skip a non-negative number of matching documents. */
-  skip(count: number): ModelQuery<Shape, Result, false, Relations, Scopes, Mode, SoftDelete> {
-    if (!Number.isInteger(count) || count < 0) {
-      throw new RangeError('Query skip must be a non-negative integer');
-    }
-    this.skipCount = count;
-    return this as unknown as ModelQuery<Shape, Result, false, Relations, Scopes, Mode, SoftDelete>;
-  }
-
-  /** Limit the number of matching documents returned. */
-  limit(count: number): this {
-    if (!Number.isInteger(count) || count < 0) {
-      throw new RangeError('Query limit must be a non-negative integer');
-    }
-    this.limitCount = count;
-    return this;
-  }
-
-  /** Return only selected fields, while retaining MongoDB's default `_id`. */
-  select<Keys extends SelectableKey<Shape> = never>(
-    fields: readonly Keys[] = [],
-  ): ModelQuery<
-    Shape,
-    SelectedDocument<Shape, Keys>,
-    CursorReady,
-    Relations,
-    Scopes,
-    Mode,
-    SoftDelete
-  > {
-    this.selectedFields = fields;
-    return this as unknown as ModelQuery<
-      Shape,
-      SelectedDocument<Shape, Keys>,
-      CursorReady,
-      Relations,
-      Scopes,
-      Mode,
-      SoftDelete
-    >;
-  }
-
-  /** Include hidden fields in the query result. */
-  show<Keys extends HiddenDocumentKey<Shape>>(
-    fields: readonly Keys[],
-  ): ModelQuery<
-    Shape,
-    Result & Pick<ModelDocument<Shape>, Keys>,
-    CursorReady,
-    Relations,
-    Scopes,
-    Mode,
-    SoftDelete
-  > {
-    this.shownFields = fields;
-    return this as unknown as ModelQuery<
-      Shape,
-      Result & Pick<ModelDocument<Shape>, Keys>,
-      CursorReady,
-      Relations,
-      Scopes,
-      Mode,
-      SoftDelete
-    >;
-  }
-
-  /** Populate declared one-way relations, including nested relation arrays. */
-  populate<Specs extends PopulateSpecs<Relations>>(
-    this: Mode extends 'scope'
-      ? never
-      : ModelQuery<Shape, Result, CursorReady, Relations, Scopes, Mode, SoftDelete>,
-    specs: Specs,
-  ): ModelQuery<
-    Shape,
-    PopulatedResult<Result, Relations, Specs>,
-    CursorReady,
-    Relations,
-    Scopes,
-    'populate',
-    SoftDelete
-  > {
-    if (this.populationMode === 'scope') {
-      throw new InvalidQueryError(
-        'A query cannot combine a population scope with explicit population',
-      );
-    }
-    this.populationMode = 'populate';
-    this.populateSpecs = specs;
-    return this as unknown as ModelQuery<
-      Shape,
-      PopulatedResult<Result, Relations, Specs>,
-      CursorReady,
-      Relations,
-      Scopes,
-      'populate',
-      SoftDelete
-    >;
-  }
-
-  /** Apply a named population scope. */
-  with<Name extends ScopeName<Scopes>>(
-    this: Mode extends 'populate'
-      ? never
-      : ModelQuery<Shape, Result, CursorReady, Relations, Scopes, Mode, SoftDelete>,
-    name: Name,
-  ): ModelQuery<
-    Shape,
-    PopulatedResult<Result, Relations, Scopes[Name] & PopulateSpecs<Relations>>,
-    CursorReady,
-    Relations,
-    Scopes,
-    'scope',
-    SoftDelete
-  > {
-    if (this.populationMode === 'populate') {
-      throw new InvalidQueryError(
-        'A query cannot combine explicit population with a population scope',
-      );
-    }
-    this.populationMode = 'scope';
-    this.populateSpecs = this.scopes[name] as PopulateSpecs<Relations>;
-    return this as unknown as ModelQuery<
-      Shape,
-      PopulatedResult<Result, Relations, Scopes[Name] & PopulateSpecs<Relations>>,
-      CursorReady,
-      Relations,
-      Scopes,
-      'scope',
-      SoftDelete
-    >;
-  }
-
-  /** Count matching documents, optionally using MongoDB's collection estimate. */
-  async count(estimate = false): Promise<number> {
-    if (estimate) {
-      if (Object.keys(this.filterSpec).length > 0 || this.softDelete.isFiltered()) {
-        throw new EstimatedCountError();
-      }
-      return this.collection.estimatedDocumentCount();
-    }
-    return this.collection.countDocuments(
-      this.effectiveFilter() as MongoFilter<StoredDocument<Shape>>,
-    );
-  }
-
-  /** Return one `_id`-ordered page and the cursor for the next page. */
-  private createCursor(after?: ObjectId): ModelCursor<Shape, Result> {
-    if (this.limitCount === undefined || this.limitCount === 0) {
-      throw new CursorQueryError('Cursor queries require a positive limit');
-    }
-    if (this.skipCount !== undefined) {
-      throw new CursorQueryError('Cursor queries do not support skip');
-    }
-    if (this.sortSpec) {
-      const keys = Object.keys(this.sortSpec);
-      if (keys.length !== 1 || this.sortSpec._id !== 'asc') {
-        throw new CursorQueryError('Cursor queries require the default _id ascending sort');
-      }
-    }
-
-    const filter = createCursorFilter(this.effectiveFilter(), after);
-    return new ModelCursor<Shape, Result>(
-      () => {
-        let cursor = this.collection
-          .find(filter as MongoFilter<StoredDocument<Shape>>)
-          .sort({ _id: 1 })
-          .limit((this.limitCount as number) + 1);
-        const projection = projectionFor(
-          this.fields,
-          this.hiddenFields,
-          this.selectedFields,
-          this.shownFields,
-        );
-        if (projection) {
-          cursor = cursor.project(projection);
-        }
-        return cursor;
-      },
-      this.limitCount,
-      (documents) => this.population.apply(documents, this.populateSpecs),
-    );
-  }
-
-  private execute(): Promise<Result[]> {
-    return this.createQueryCursor()
-      .toArray()
-      .then((documents) =>
-        this.population.apply(documents as unknown as Result[], this.populateSpecs),
-      );
-  }
-
-  async first(): Promise<Result | null> {
-    const documents = await this.createQueryCursor().limit(1).toArray();
-    const populated = await this.population.apply(
-      documents as unknown as Result[],
-      this.populateSpecs,
-    );
-    return populated[0] ?? null;
-  }
-
-  private createQueryCursor() {
-    let cursor = this.collection.find(this.effectiveFilter() as MongoFilter<StoredDocument<Shape>>);
-    if (this.sortSpec) {
-      cursor = cursor.sort(this.sortSpec as Sort);
-    }
-    if (this.skipCount !== undefined) {
-      cursor = cursor.skip(this.skipCount);
-    }
-    if (this.limitCount !== undefined) {
-      cursor = cursor.limit(this.limitCount);
-    }
-    const projection = projectionFor(
-      this.fields,
-      this.hiddenFields,
-      this.selectedFields,
-      this.shownFields,
-    );
-    if (projection) {
-      cursor = cursor.project(projection);
-    }
-    return cursor;
-  }
-
-  then<TResult1 = Result[], TResult2 = never>(
-    onfulfilled?: ((value: Result[]) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
-  ): PromiseLike<TResult1 | TResult2> {
-    return this.execute().then(onfulfilled, onrejected);
-  }
-}

package/src/query/query.ts

@@ -1,14 +0,0 @@
-export { ModelQuery } from './many-query.js';
-export { ModelCursor } from './cursor.js';
-export type {
-  HiddenDocumentKey,
-  ModelFilter,
-  ModelSort,
-  PopulateSpec,
-  PopulateSpecs,
-  PopulatedResult,
-  SelectedDocument,
-  SelectableKey,
-  StoredDocument,
-  VisibleDocument,
-} from './types.js';

package/src/query/runtime.ts

@@ -1,140 +0,0 @@
-import type { Collection, Filter, ObjectId } from 'mongodb';
-
-import type { Db } from '../connection/database.js';
-import {
-  applySoftDeleteFilter,
-  type DeletedQueryMode,
-  type SoftDeleteMode,
-} from '../model/soft-delete.js';
-import type { SchemaRelationMap, SchemaShape } from '../schema/index.js';
-import type { ModelFilter, StoredDocument } from './types.js';
-
-export type RuntimePopulateSpec = {
-  ref: string;
-  select?: readonly string[];
-  populate?: readonly RuntimePopulateSpec[];
-};
-
-export type DeletedMode = SoftDeleteMode;
-
-export const normalizeProjectionFields = (fields: readonly string[]): string[] => {
-  const unique = new Set(fields);
-  return [...unique].filter((field) => {
-    let separator = field.indexOf('.');
-    while (separator !== -1) {
-      if (unique.has(field.slice(0, separator))) return false;
-      separator = field.indexOf('.', separator + 1);
-    }
-    return true;
-  });
-};
-
-export const projectionFor = (
-  fields: readonly string[],
-  hiddenFields: readonly string[],
-  selectedFields: readonly string[] | undefined,
-  shownFields: readonly string[],
-): Record<string, 1> | undefined => {
-  const effectiveSelectedFields = selectedFields?.length ? selectedFields : undefined;
-  if (!effectiveSelectedFields && hiddenFields.length === 0 && shownFields.length === 0) {
-    return undefined;
-  }
-  const hidden = new Set(hiddenFields);
-  const visibleFields = effectiveSelectedFields ?? fields.filter((field) => !hidden.has(field));
-  return Object.fromEntries(
-    normalizeProjectionFields([...visibleFields, ...shownFields]).map((field) => [field, 1]),
-  );
-};
-
-export class SoftDeleteState<Shape extends SchemaShape> {
-  private mode: DeletedMode = 'active';
-
-  constructor(private readonly enabled: boolean) {}
-
-  includeDeleted(): void {
-    this.mode = 'all';
-  }
-
-  deleted(mode: DeletedQueryMode): void {
-    this.mode = mode === 'include' ? 'all' : 'deleted';
-  }
-
-  isFiltered(): boolean {
-    return this.enabled && this.mode !== 'all';
-  }
-
-  effectiveFilter(filter: ModelFilter<Shape>): ModelFilter<Shape> {
-    return applySoftDeleteFilter(filter, this.mode);
-  }
-}
-
-export class PopulationExecutor<Relations extends SchemaRelationMap> {
-  constructor(
-    private readonly db: Db,
-    private readonly relations: Relations,
-  ) {}
-
-  async apply<Result extends object>(
-    documents: Result[],
-    specs: readonly RuntimePopulateSpec[],
-  ): Promise<Result[]> {
-    await Promise.all(
-      documents.map(async (document) => {
-        for (const spec of specs) {
-          await this.populateDocument(document as Record<string, unknown>, spec, this.relations);
-        }
-      }),
-    );
-    return documents;
-  }
-
-  async applyOne<Result extends object>(
-    document: Result,
-    specs: readonly RuntimePopulateSpec[],
-  ): Promise<Result> {
-    await this.apply([document], specs);
-    return document;
-  }
-
-  private async populateDocument(
-    document: Record<string, unknown>,
-    spec: RuntimePopulateSpec,
-    relations: SchemaRelationMap,
-  ): Promise<void> {
-    const relation = relations[spec.ref];
-    const target = relation.resolve();
-    const value = document[relation.localField];
-    const targetRelations = target.relationMap as SchemaRelationMap;
-    const nestedRelationFields = (spec.populate ?? []).map(
-      (nested) => targetRelations[nested.ref].localField,
-    );
-    const hiddenTargetFields = new Set(target.hiddenFields);
-    const projectionFields = normalizeProjectionFields([
-      ...new Set(spec.select ?? target.fields.filter((field) => !hiddenTargetFields.has(field))),
-      ...nestedRelationFields,
-    ]);
-    const related = value
-      ? await this.db
-          .collectionFor(target)
-          .findOne(
-            { [relation.foreignField]: value },
-            { projection: Object.fromEntries(projectionFields.map((field) => [field, 1])) },
-          )
-      : null;
-    if (related && spec.populate) {
-      for (const nested of spec.populate) {
-        await this.populateDocument(related, nested, targetRelations);
-      }
-    }
-    document[spec.ref] = related;
-  }
-}
-
-export const createCursorFilter = <Shape extends SchemaShape>(
-  filter: ModelFilter<Shape>,
-  after?: ObjectId,
-): ModelFilter<Shape> =>
-  (after ? { $and: [filter, { _id: { $gt: after } }] } : filter) as ModelFilter<Shape>;
-
-export type QueryCollection<Shape extends SchemaShape> = Collection<StoredDocument<Shape>>;
-export type MongoQueryFilter<Shape extends SchemaShape> = Filter<StoredDocument<Shape>>;

package/src/query/types.ts

@@ -1,134 +0,0 @@
-import { ObjectId, type Condition, type Document, type RootFilterOperators } from 'mongodb';
-
-import type { SchemaShape } from '../schema/contracts.js';
-import type { Infer, Schema, SchemaRelationMap } from '../schema/index.js';
-import type { ModelCursor } from './cursor.js';
-
-export type StoredDocument<Shape extends SchemaShape> = Infer<Schema<Shape>> & Document;
-
-type ModelFilterForDocument<
-  DocumentShape extends Document,
-  FieldShape extends object = DocumentShape,
-> = Partial<{
-  [Key in keyof FieldShape]: Condition<FieldShape[Key]>;
-}> &
-  Partial<
-    Pick<
-      RootFilterOperators<DocumentShape>,
-      '$comment' | '$expr' | '$jsonSchema' | '$text' | '$where'
-    >
-  > & {
-    $and?: ModelFilterForDocument<DocumentShape, FieldShape>[];
-    $nor?: ModelFilterForDocument<DocumentShape, FieldShape>[];
-    $or?: ModelFilterForDocument<DocumentShape, FieldShape>[];
-  };
-
-export type ModelFilter<Shape extends SchemaShape> = ModelFilterForDocument<
-  StoredDocument<Shape>,
-  Infer<Schema<Shape>>
->;
-
-type SortDirection = 'asc' | 'desc';
-export type ModelSort<Shape extends SchemaShape> = Partial<
-  Record<Extract<keyof Infer<Schema<Shape>>, string>, SortDirection>
->;
-
-export type ModelDocument<Shape extends SchemaShape> = Infer<Schema<Shape>>;
-export type HiddenKey<Shape extends SchemaShape> = {
-  [Key in keyof Shape]: Shape[Key] extends { readonly __hidden: true } ? Key : never;
-}[keyof Shape];
-export type HiddenDocumentKey<Shape extends SchemaShape> = Extract<
-  HiddenKey<Shape>,
-  keyof ModelDocument<Shape>
-> &
-  string;
-type NestedDocumentKeys<Value, Prefix extends string = ''> = Value extends object
-  ? Value extends ObjectId | Date
-    ? never
-    : {
-        [Key in Extract<keyof Value, string>]: NonNullable<Value[Key]> extends object
-          ? `${Prefix}${Key}` | `${Prefix}${Key}.${NestedDocumentKeys<NonNullable<Value[Key]>>}`
-          : `${Prefix}${Key}`;
-      }[Extract<keyof Value, string>]
-  : never;
-type NestedSelectableKey<Shape extends SchemaShape> = {
-  [Key in Extract<keyof Shape, string>]: Key extends keyof ModelDocument<Shape>
-    ? NonNullable<ModelDocument<Shape>[Key]> extends object
-      ? `${Key}.${NestedDocumentKeys<NonNullable<ModelDocument<Shape>[Key]>>}`
-      : never
-    : never;
-}[Extract<keyof Shape, string>];
-export type CursorMethod<
-  Shape extends SchemaShape,
-  Result extends object,
-  Ready extends boolean,
-> = Ready extends true ? (after?: ObjectId) => ModelCursor<Shape, Result> : undefined;
-export type SelectableKey<Shape extends SchemaShape> =
-  | Exclude<Extract<keyof ModelDocument<Shape>, string>, '_id' | HiddenDocumentKey<Shape>>
-  | NestedSelectableKey<Shape>;
-type PathSelection<Value, Path extends string> = Path extends `${infer Head}.${infer Tail}`
-  ? Head extends keyof Value
-    ? { [Key in Head]: PathSelection<NonNullable<Value[Key]>, Tail> }
-    : never
-  : Path extends keyof Value
-    ? Pick<Value, Path>
-    : never;
-type UnionToIntersection<Value> = (Value extends unknown ? (input: Value) => void : never) extends (
-  input: infer Intersection,
-) => void
-  ? Intersection
-  : never;
-type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
-export type VisibleDocument<Shape extends SchemaShape> = Omit<
-  ModelDocument<Shape>,
-  Extract<HiddenKey<Shape>, keyof ModelDocument<Shape>>
->;
-export type SelectedDocument<Shape extends SchemaShape, Key extends SelectableKey<Shape>> = [
-  Key,
-] extends [never]
-  ? VisibleDocument<Shape>
-  : Simplify<
-      Pick<ModelDocument<Shape>, '_id'> &
-        UnionToIntersection<PathSelection<ModelDocument<Shape>, Extract<Key, string>>>
-    >;
-type RelationTarget<Relation> = Relation extends { resolve: () => infer Target } ? Target : never;
-type RelationDocument<Relation> =
-  RelationTarget<Relation> extends Schema<infer TargetShape, any>
-    ? Infer<Schema<TargetShape>>
-    : never;
-type RelationMapOf<Relation> =
-  RelationTarget<Relation> extends { readonly relationMap: infer TargetRelations }
-    ? TargetRelations extends SchemaRelationMap
-      ? TargetRelations
-      : {}
-    : {};
-export type ScopeName<Scopes> = Extract<keyof Scopes, string>;
-export type PopulationMode = 'none' | 'populate' | 'scope';
-type RelationSelect<Relation> =
-  RelationTarget<Relation> extends Schema<infer TargetShape, any>
-    ? Exclude<SelectableKey<TargetShape>, '_id'>
-    : never;
-
-export type PopulateSpec<Relations extends SchemaRelationMap> = {
-  [Name in Extract<keyof Relations, string>]: {
-    ref: Name;
-    select?: readonly RelationSelect<Relations[Name]>[];
-    populate?: PopulateSpecs<RelationMapOf<Relations[Name]>>;
-  };
-}[Extract<keyof Relations, string>];
-export type PopulateSpecs<Relations extends SchemaRelationMap> = readonly PopulateSpec<Relations>[];
-export type PopulatedResult<
-  Result extends object,
-  Relations extends SchemaRelationMap,
-  Specs extends PopulateSpecs<Relations>,
-> = Omit<Result, Extract<Specs[number]['ref'], keyof Result>> & {
-  [Spec in Specs[number] as Spec['ref']]: PopulatedRelation<Relations[Spec['ref']], Spec> | null;
-};
-
-type PopulatedRelation<Relation, Spec> = Spec extends {
-  populate: infer Nested extends PopulateSpecs<RelationMapOf<Relation>>;
-}
-  ? RelationDocument<Relation> extends infer PopulatedDocument extends object
-    ? PopulatedResult<PopulatedDocument, RelationMapOf<Relation>, Nested>
-    : never
-  : RelationDocument<Relation>;