@mongorm/orm 0.1.1-beta.1 → 0.1.1-beta.2

package/src/api.ts

@@ -1,47 +0,0 @@
-import { z } from 'zod';
-
-import { createRef } from './relations/definitions.js';
-import type { RefField, SchemaLike } from './relations/definitions.js';
-import { createSchemaRegistry } from './relations/registry.js';
-import type { SchemaShape } from './schema/contracts.js';
-import { objectId, withZodNamespace } from './schema/scalars.js';
-import { Schema } from './schema/schema.js';
-
-type ZodConstructorKey = {
-  [Key in keyof typeof z]: Key extends string
-    ? Key extends Lowercase<Key>
-      ? (typeof z)[Key] extends (...args: any[]) => any
-        ? Key
-        : never
-      : never
-    : never;
-}[keyof typeof z];
-type ZodConstructors = Pick<typeof z, ZodConstructorKey>;
-
-/** The public schema-construction API. */
-export type OrmApi = ZodConstructors & {
-  /** Define a typed object schema. */
-  schema<Shape extends SchemaShape>(shape: Shape): Schema<Shape>;
-  /** Build a registry of named schemas and their relation graph. */
-  defineSchemas<const Registry extends Record<string, SchemaLike>>(
-    registry: Registry,
-  ): ReturnType<typeof createSchemaRegistry<Registry>>;
-  /** Create a MongoDB ObjectId field. */
-  objectId: typeof objectId;
-  /** Create a string ID field linked to another schema. */
-  ref<Target extends SchemaLike>(resolve: () => Target): RefField<Target>;
-};
-
-/** The ORM schema API with the complete native Zod namespace. */
-const zodConstructors = Object.fromEntries(
-  Object.entries(z).filter(
-    ([name, value]) => name === name.toLowerCase() && typeof value === 'function',
-  ),
-) as ZodConstructors;
-
-export const orm: OrmApi = Object.assign({}, withZodNamespace(zodConstructors), {
-  schema: <Shape extends SchemaShape>(shape: Shape) => new Schema(shape),
-  defineSchemas: createSchemaRegistry,
-  objectId,
-  ref: createRef,
-});

package/src/connection/database.ts

@@ -1,145 +0,0 @@
-import {
-  MongoClient,
-  type Collection,
-  type Document,
-  type IndexDescription,
-  type MongoClientOptions,
-  type Db as MongoDatabase,
-} from 'mongodb';
-
-import { Model } from '../model/model.js';
-import type {
-  Schema,
-  SchemaOptions,
-  SchemaLike,
-  SchemaShape,
-  SchemaRelationMap,
-  ScopeDefinitions,
-} from '../schema/index.js';
-import { DatabaseNotConnectedError } from '../validation/errors.js';
-
-export type SchemaRegistry = Record<string, SchemaLike>;
-
-/** Configuration for a MongoDB connection. */
-export interface DbOptions<Registry extends SchemaRegistry = SchemaRegistry> {
-  /** MongoDB connection string. */
-  uri: string;
-  /** Logical database name. */
-  database: string;
-  /** Optional native MongoDB client options. */
-  clientOptions?: MongoClientOptions;
-  /** Schemas registered as plural database model properties. */
-  schema?: Registry;
-}
-
-type ModelForSchema<SchemaType> =
-  SchemaType extends Schema<infer Shape, infer Relations, infer Scopes, infer Options>
-    ? Model<Shape, Relations, Scopes, Options>
-    : never;
-
-export type DatabaseModels<Registry extends SchemaRegistry> = {
-  readonly [Name in keyof Registry]: ModelForSchema<Registry[Name]>;
-};
-
-type RegistryOfBuilder<Builder extends { readonly __registry?: SchemaRegistry }> = NonNullable<
-  Builder['__registry']
->;
-
-/** Owns a MongoDB client and creates schema-bound models. */
-export class Db<Registry extends SchemaRegistry = SchemaRegistry> {
-  private readonly client: MongoClient;
-  private database: MongoDatabase | null = null;
-  private readonly schemaCollections = new Map<SchemaLike, string>();
-
-  /** Create a disconnected database handle. */
-  constructor(private readonly options: DbOptions<Registry>) {
-    this.client = new MongoClient(options.uri, options.clientOptions);
-    for (const [name, schema] of Object.entries(options.schema ?? {})) {
-      this.registerSchema(schema, name);
-      let model: Model<SchemaShape, SchemaRelationMap, ScopeDefinitions> | undefined;
-      Object.defineProperty(this, name, {
-        configurable: false,
-        enumerable: true,
-        get: () => (model ??= this.model(name, schema)),
-      });
-    }
-  }
-
-  /** Connect to MongoDB and select the configured database. */
-  async connect(): Promise<void> {
-    await this.client.connect();
-    this.database = this.client.db(this.options.database);
-  }
-
-  /** Close the MongoDB client and release its resources. */
-  async disconnect(): Promise<void> {
-    await this.client.close();
-    this.database = null;
-  }
-
-  /** Create a model bound to a MongoDB collection and schema. */
-  model<
-    Shape extends SchemaShape,
-    Relations extends SchemaRelationMap,
-    Scopes extends ScopeDefinitions,
-    Options extends SchemaOptions,
-  >(
-    name: string,
-    schema: Schema<Shape, Relations, Scopes, Options>,
-  ): Model<Shape, Relations, Scopes, Options> {
-    this.registerSchema(schema, name);
-    return new Model(this, name, schema);
-  }
-
-  private registerSchema(schema: SchemaLike, name: string): void {
-    const registeredName = this.schemaCollections.get(schema);
-    if (registeredName && registeredName !== name) {
-      throw new Error(
-        `Schema is already registered with collection "${registeredName}" and cannot also use "${name}"`,
-      );
-    }
-    this.schemaCollections.set(schema, name);
-  }
-
-  /** Resolve a registered schema to its MongoDB collection. */
-  collectionFor(schema: SchemaLike): Collection<Document> {
-    const name = this.schemaCollections.get(schema);
-    if (!name) throw new Error('Schema is not registered with this database');
-    return this.native.collection<Document>(name);
-  }
-
-  /** Explicitly create all indexes declared by registered schemas. */
-  async sync(): Promise<Record<string, string[]>> {
-    const synchronized: Record<string, string[]> = {};
-    for (const [schema, name] of this.schemaCollections) {
-      const definitions = schema.indexDefinitions ?? [];
-      synchronized[name] = definitions.length
-        ? await this.collectionFor(schema).createIndexes(
-            definitions.map(({ fields, options }) => ({
-              ...options,
-              key: fields,
-            })) as IndexDescription[],
-          )
-        : [];
-    }
-    return synchronized;
-  }
-
-  /** Return the selected database, failing if `connect()` was not called. */
-  get native(): MongoDatabase {
-    if (!this.database) throw new DatabaseNotConnectedError();
-    return this.database;
-  }
-}
-
-/** Create a disconnected MongoDB database handle. */
-export function createDatabase<const Registry extends SchemaRegistry>(
-  options: DbOptions<Registry> & { schema: Registry },
-): Db<Registry> & DatabaseModels<Registry>;
-export function createDatabase<const Builder extends { readonly __registry?: SchemaRegistry }>(
-  options: Omit<DbOptions<RegistryOfBuilder<Builder>>, 'schema'> & { schema: Builder },
-): Db<RegistryOfBuilder<Builder>> & DatabaseModels<RegistryOfBuilder<Builder>>;
-export function createDatabase(options: DbOptions): Db;
-export function createDatabase(options: DbOptions): Db {
-  return new Db(options);
-}

package/src/index.ts

@@ -1,50 +0,0 @@
-export { ObjectId } from 'mongodb';
-export { orm } from './api.js';
-export type { OrmApi } from './api.js';
-export { Schema } from './schema/index.js';
-export type { Infer, InferInput, InferShape } from './schema/index.js';
-export type { SchemaDefinition, SchemaShape } from './schema/index.js';
-export type {
-  ManagedField,
-  SchemaIndex,
-  SchemaIndexFields,
-  SchemaOptions,
-} from './schema/index.js';
-export { hasSoftDelete } from './schema/index.js';
-export type { SoftDeleteEnabled } from './schema/index.js';
-export type {
-  RefDefinition,
-  RefField,
-  RelationMap,
-  SchemaLike,
-  SchemaRelation,
-  SchemaRelationMap,
-} from './schema/index.js';
-export { createDatabase, Db } from './connection/database.js';
-export type {
-  RelationDefinitions,
-  SchemaRegistryBuilder,
-  ScopeDefinitionsBySchema,
-} from './relations/registry.js';
-export {
-  CursorQueryError,
-  DatabaseNotConnectedError,
-  EstimatedCountError,
-  InvalidQueryError,
-  OrmError,
-} from './validation/errors.js';
-export { Model } from './model/model.js';
-export { ModelCursor, ModelQuery } from './query/query.js';
-export type {
-  HiddenDocumentKey,
-  ModelFilter,
-  ModelSort,
-  PopulateSpec,
-  PopulateSpecs,
-  PopulatedResult,
-  SelectedDocument,
-  SelectableKey,
-  StoredDocument,
-  VisibleDocument,
-} from './query/query.js';
-export type { DatabaseModels, DbOptions, SchemaRegistry } from './connection/database.js';

package/src/model/model.ts

@@ -1,212 +0,0 @@
-import {
-  ObjectId,
-  type Collection,
-  type DeleteResult,
-  type Filter as MongoFilter,
-  type OptionalUnlessRequiredId,
-  type UpdateFilter,
-} from 'mongodb';
-
-import type { Db } from '../connection/database.js';
-import { ModelQuery } from '../query/query.js';
-import type { ModelFilter, StoredDocument, VisibleDocument } from '../query/query.js';
-import { hasSoftDelete } from '../schema/index.js';
-import type {
-  Infer,
-  InferInput,
-  Schema,
-  SchemaOptions,
-  SoftDeleteEnabled,
-  SchemaRelationMap,
-  SchemaShape,
-  ScopeDefinitions,
-} from '../schema/index.js';
-import { applySoftDeleteFilter } from './soft-delete.js';
-
-type CreateInput<Shape extends SchemaShape, Options extends SchemaOptions> = Omit<
-  InferInput<Schema<Shape, {}, {}, Options>>,
-  '_id'
->;
-type UpdateInput<Shape extends SchemaShape, Options extends SchemaOptions> = Partial<
-  Omit<InferInput<Schema<Shape, {}, {}, Options>>, '_id'>
->;
-type ModelDocument<
-  Shape extends SchemaShape,
-  Relations extends SchemaRelationMap,
-  Scopes extends ScopeDefinitions,
-  Options extends SchemaOptions,
-> = Infer<Schema<Shape, Relations, Scopes, Options>>;
-/** A MongoDB collection with CRUD operations derived from a schema. */
-export class Model<
-  Shape extends SchemaShape,
-  Relations extends SchemaRelationMap = {},
-  Scopes extends ScopeDefinitions = {},
-  Options extends SchemaOptions = {},
-> {
-  declare readonly bulk: {
-    create: (
-      inputs: readonly CreateInput<Shape, Options>[],
-    ) => Promise<ModelDocument<Shape, Relations, Scopes, Options>[]>;
-  };
-  declare readonly restore: SoftDeleteEnabled<Options> extends true
-    ? (
-        filter: ModelFilter<Shape>,
-      ) => Promise<Infer<Schema<Shape, Relations, Scopes, Options>> | null>
-    : never;
-  declare readonly purge: SoftDeleteEnabled<Options> extends true
-    ? (filter: ModelFilter<Shape>) => Promise<DeleteResult>
-    : never;
-
-  /** Create a model bound to a database collection and schema. */
-  constructor(
-    private readonly db: Db,
-    readonly name: string,
-    private readonly schema: Schema<Shape, Relations, Scopes, Options>,
-  ) {
-    Object.defineProperty(this, 'bulk', {
-      configurable: false,
-      enumerable: false,
-      value: {
-        create: (inputs: readonly CreateInput<Shape, Options>[]) => this.bulkCreate(inputs),
-      },
-    });
-    if (hasSoftDelete(schema.optionsConfig)) {
-      Object.defineProperties(this, {
-        restore: {
-          configurable: false,
-          enumerable: false,
-          value: (filter: ModelFilter<Shape>) => this.restoreDocument(filter),
-        },
-        purge: {
-          configurable: false,
-          enumerable: false,
-          value: (filter: ModelFilter<Shape>) => this.purgeDocuments(filter),
-        },
-      });
-    }
-  }
-
-  private get collection(): Collection<StoredDocument<Shape>> {
-    return this.db.native.collection<StoredDocument<Shape>>(this.name);
-  }
-
-  private activeFilter(filter: ModelFilter<Shape>): ModelFilter<Shape> {
-    return hasSoftDelete(this.schema.optionsConfig)
-      ? applySoftDeleteFilter(filter, 'active')
-      : filter;
-  }
-
-  /** Validate and insert one document, generating its ObjectId. */
-  async create(
-    input: CreateInput<Shape, Options>,
-  ): Promise<ModelDocument<Shape, Relations, Scopes, Options>> {
-    const document = this.prepareDocument(input);
-    await this.collection.insertOne(
-      document as unknown as OptionalUnlessRequiredId<StoredDocument<Shape>>,
-    );
-    return document as ModelDocument<Shape, Relations, Scopes, Options>;
-  }
-
-  private prepareDocument(input: CreateInput<Shape, Options>): Record<string, unknown> {
-    const now = new Date();
-    const document: Record<string, unknown> = {
-      _id: new ObjectId(),
-      ...this.schema.parse(input),
-    };
-    if (this.schema.optionsConfig.timestamps) {
-      document.createdAt = now;
-      document.updatedAt = now;
-    }
-    if (hasSoftDelete(this.schema.optionsConfig)) document.deletedAt = null;
-    return document;
-  }
-
-  private async bulkCreate(
-    inputs: readonly CreateInput<Shape, Options>[],
-  ): Promise<ModelDocument<Shape, Relations, Scopes, Options>[]> {
-    if (inputs.length === 0) return [];
-    const documents = inputs.map((input) => this.prepareDocument(input));
-    await this.collection.insertMany(
-      documents as unknown as OptionalUnlessRequiredId<StoredDocument<Shape>>[],
-    );
-    return documents as ModelDocument<Shape, Relations, Scopes, Options>[];
-  }
-
-  /** Build a query for all documents matching a MongoDB filter. */
-  find(
-    filter: ModelFilter<Shape> = {},
-  ): ModelQuery<
-    Shape,
-    VisibleDocument<Shape>,
-    true,
-    Relations,
-    Scopes,
-    'none',
-    SoftDeleteEnabled<Options>
-  > {
-    return new ModelQuery(
-      this.collection,
-      filter,
-      this.schema.fields,
-      this.schema.hiddenFields,
-      this.db,
-      this.schema.relationMap,
-      this.schema.scopeMap,
-      hasSoftDelete(this.schema.optionsConfig),
-    );
-  }
-
-  /** Validate and apply a partial update to the first matching document. */
-  async update(
-    filter: ModelFilter<Shape>,
-    patch: UpdateInput<Shape, Options>,
-  ): Promise<Infer<Schema<Shape, Relations, Scopes, Options>> | null> {
-    const parsedPatch = this.schema.parsePartial(patch) as Record<string, unknown>;
-    const managedFields = new Set(['createdAt', 'updatedAt', 'deletedAt']);
-    managedFields.forEach((field) => delete parsedPatch[field]);
-    if (this.schema.optionsConfig.timestamps) parsedPatch.updatedAt = new Date();
-    return (await this.collection.findOneAndUpdate(
-      this.activeFilter(filter) as MongoFilter<StoredDocument<Shape>>,
-      { $set: parsedPatch } as unknown as UpdateFilter<StoredDocument<Shape>>,
-      { returnDocument: 'after' },
-    )) as unknown as Infer<Schema<Shape, Relations, Scopes, Options>> | null;
-  }
-
-  /** Restore matching soft-deleted documents. */
-  private async restoreDocument(
-    filter: ModelFilter<Shape>,
-  ): Promise<Infer<Schema<Shape, Relations, Scopes, Options>> | null> {
-    if (!hasSoftDelete(this.schema.optionsConfig)) {
-      throw new Error('Restore requires softdelete schema options');
-    }
-    const patch: Record<string, unknown> = { deletedAt: null };
-    if (this.schema.optionsConfig.timestamps) patch.updatedAt = new Date();
-    return (await this.collection.findOneAndUpdate(
-      applySoftDeleteFilter(filter, 'deleted') as MongoFilter<StoredDocument<Shape>>,
-      { $set: patch } as UpdateFilter<StoredDocument<Shape>>,
-      { returnDocument: 'after' },
-    )) as unknown as Infer<Schema<Shape, Relations, Scopes, Options>> | null;
-  }
-
-  /** Delete every document matching a MongoDB filter. */
-  async delete(filter: ModelFilter<Shape>): Promise<DeleteResult> {
-    if (!hasSoftDelete(this.schema.optionsConfig)) {
-      return this.collection.deleteMany(filter as MongoFilter<StoredDocument<Shape>>);
-    }
-    const patch: Record<string, unknown> = { deletedAt: new Date() };
-    if (this.schema.optionsConfig.timestamps) patch.updatedAt = new Date();
-    const result = await this.collection.updateMany(
-      applySoftDeleteFilter(filter, 'active') as MongoFilter<StoredDocument<Shape>>,
-      { $set: patch } as UpdateFilter<StoredDocument<Shape>>,
-    );
-    return {
-      acknowledged: result.acknowledged,
-      deletedCount: result.modifiedCount,
-    };
-  }
-
-  /** Permanently delete matching documents, including soft-deleted documents. */
-  private purgeDocuments(filter: ModelFilter<Shape>): Promise<DeleteResult> {
-    return this.collection.deleteMany(filter as MongoFilter<StoredDocument<Shape>>);
-  }
-}

package/src/model/soft-delete.ts

@@ -1,15 +0,0 @@
-import type { ModelFilter } from '../query/types.js';
-import type { SchemaShape } from '../schema/contracts.js';
-
-export type SoftDeleteMode = 'active' | 'deleted' | 'all';
-export type DeletedQueryMode = 'only' | 'include';
-
-export const applySoftDeleteFilter = <Shape extends SchemaShape>(
-  filter: ModelFilter<Shape>,
-  mode: SoftDeleteMode,
-): ModelFilter<Shape> => {
-  if (mode === 'all') return filter;
-
-  const deletionFilter = mode === 'deleted' ? { deletedAt: { $ne: null } } : { deletedAt: null };
-  return { $and: [deletionFilter, filter] } as ModelFilter<Shape>;
-};

package/src/query/cursor.ts

@@ -1,36 +0,0 @@
-import { ObjectId, type FindCursor, type WithId } from 'mongodb';
-
-import type { SchemaShape } from '../schema/contracts.js';
-import type { StoredDocument } from './types.js';
-
-/** A lazy async iterable for one cursor-pagination page. */
-export class ModelCursor<
-  Shape extends SchemaShape,
-  Result extends object,
-> implements AsyncIterable<Result> {
-  next: ObjectId | null = null;
-
-  constructor(
-    private readonly open: () => FindCursor<WithId<StoredDocument<Shape>>>,
-    private readonly pageSize: number,
-    private readonly transform?: (documents: Result[]) => Promise<Result[]>,
-  ) {}
-
-  async *[Symbol.asyncIterator](): AsyncGenerator<Result> {
-    const cursor = this.open();
-    try {
-      const documents: Result[] = [];
-      for (let index = 0; index < this.pageSize && (await cursor.hasNext()); index += 1) {
-        documents.push((await cursor.next()) as unknown as Result);
-      }
-      const transformed = this.transform ? await this.transform(documents) : documents;
-      for (const document of transformed) {
-        yield document;
-      }
-      const last = transformed.at(-1) as (Result & { _id: ObjectId }) | undefined;
-      this.next = (await cursor.hasNext()) && last ? last._id : null;
-    } finally {
-      await cursor.close();
-    }
-  }
-}