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

package/src/validation/errors.ts

@@ -1,39 +0,0 @@
-/** Base error type emitted by the ORM. */
-export class OrmError extends Error {
-  constructor(
-    message: string,
-    readonly code: string,
-  ) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-/** Raised when an operation requires a connected database. */
-export class DatabaseNotConnectedError extends OrmError {
-  constructor() {
-    super('Database is not connected', 'DATABASE_NOT_CONNECTED');
-  }
-}
-
-/** Raised when a query configuration is not supported. */
-export class InvalidQueryError extends OrmError {
-  constructor(message: string, code = 'INVALID_QUERY') {
-    super(message, code);
-  }
-}
-
-/** Raised when cursor pagination options are incompatible. */
-export class CursorQueryError extends InvalidQueryError {
-  constructor(message: string) {
-    super(message, 'CURSOR_QUERY_INVALID');
-  }
-}
-
-/** Raised when an estimated count is requested with a filter. */
-export class EstimatedCountError extends InvalidQueryError {
-  constructor() {
-    super('Estimated query counts do not support filters', 'ESTIMATED_COUNT_FILTER_UNSUPPORTED');
-  }
-}

package/tests/connection/database.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { createDatabase, orm } from '../../src/index.js';
-
-describe('database connection', () => {
-  it('registers schemas as database models', () => {
-    const users = orm.schema({ name: orm.string() });
-    const db = createDatabase({
-      uri: 'mongodb://127.0.0.1:27017',
-      database: 'mongorm_registry_test',
-      schema: { users },
-    });
-
-    expect(db.users.name).toBe('users');
-    expect(db.users).toBe(db.users);
-  });
-
-  it('rejects registering one schema to multiple collections', () => {
-    const users = orm.schema({ name: orm.string() });
-    const db = createDatabase({
-      uri: 'mongodb://127.0.0.1:27017',
-      database: 'mongorm_registry_test',
-      schema: { users },
-    });
-
-    expect(() => db.model('accounts', users)).toThrow('already registered with collection "users"');
-  });
-});

package/tests/env.ts

@@ -1,14 +0,0 @@
-import * as dotenv from 'dotenv';
-import * as z from 'zod';
-
-dotenv.config({
-  quiet: true,
-});
-
-const schema = z.object({
-  MONGODB_URI: z.string().min(1),
-  MONGODB_DATABASE: z.string().min(1),
-});
-
-/** Required MongoDB integration-test configuration. */
-export const env = schema.parse(process.env);

package/tests/model/bulk.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import type { Db } from '../../src/connection/database.js';
-import { orm } from '../../src/index.js';
-import { Model } from '../../src/model/model.js';
-
-describe('bulk model operations', () => {
-  it('validates inputs and inserts all prepared documents at once', async () => {
-    const insertMany = vi
-      .fn<(documents: unknown[]) => Promise<unknown>>()
-      .mockResolvedValue({ acknowledged: true, insertedCount: 2 });
-    const collection = { insertMany };
-    const database = {
-      native: { collection: () => collection },
-    } as unknown as Db;
-    const model = new Model(database, 'users', orm.schema({ name: orm.string() }));
-
-    const created = await model.bulk.create([{ name: 'Ada' }, { name: 'Alan' }]);
-
-    expect(insertMany).toHaveBeenCalledOnce();
-    expect(insertMany).toHaveBeenCalledWith(created);
-    expect(created).toHaveLength(2);
-    expect(created[0]._id).toBeDefined();
-    expect(created[1]._id).toBeDefined();
-    expect(created[0]._id).not.toEqual(created[1]._id);
-  });
-
-  it('validates the complete batch before writing', async () => {
-    const insertMany = vi.fn<(documents: unknown[]) => Promise<unknown>>();
-    const database = {
-      native: { collection: () => ({ insertMany }) },
-    } as unknown as Db;
-    const model = new Model(database, 'users', orm.schema({ name: orm.string() }));
-
-    await expect(model.bulk.create([{ name: 'Ada' }, { name: 42 as never }])).rejects.toThrow(
-      /string/,
-    );
-    expect(insertMany).not.toHaveBeenCalled();
-  });
-});

package/tests/model/crud.integration.test.ts

@@ -1,160 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-
-import { ObjectId, createDatabase, orm } from '../../src/index.js';
-import { env } from '../env.js';
-
-const runDatabaseTests = Boolean(env.MONGODB_URI);
-
-const database = createDatabase({
-  uri: env.MONGODB_URI ?? 'mongodb://127.0.0.1:27017',
-  database: env.MONGODB_DATABASE,
-});
-
-const ticketSchema = orm.schema({
-  title: orm.string(),
-  status: orm.enum(['open', 'closed']),
-  priority: orm.number(),
-  owner: orm.objectId(),
-  secret: orm.string().hidden(),
-});
-const ownerSchema = orm.schema({ name: orm.string() });
-const relatedTicketSchema = ticketSchema.relations({ owner: () => ownerSchema });
-
-const owners = database.model('owners', ownerSchema);
-const tickets = database.model('tickets', relatedTicketSchema);
-
-describe.skipIf(!runDatabaseTests)('database CRUD', () => {
-  beforeAll(() => database.connect());
-  beforeEach(async () => {
-    await tickets.delete({});
-    await owners.delete({});
-  });
-  afterAll(() => database.disconnect());
-
-  it('creates, filters, finds, updates, and deletes typed documents', async () => {
-    const owner = await owners.create({ name: 'Ada' });
-    const otherOwner = await owners.create({ name: 'Alan' });
-    const first = await tickets.create({
-      title: 'Design API',
-      status: 'open',
-      priority: 1,
-      owner: owner._id,
-      secret: 'first-secret',
-    });
-    await tickets.create({
-      title: 'Implement API',
-      status: 'open',
-      priority: 2,
-      owner: owner._id,
-      secret: 'second-secret',
-    });
-    await tickets.create({
-      title: 'Document API',
-      status: 'closed',
-      priority: 3,
-      owner: otherOwner._id,
-      secret: 'third-secret',
-    });
-
-    expect(first._id).toBeInstanceOf(ObjectId);
-    expect((await tickets.find({}))[0]).not.toHaveProperty('secret');
-    expect((await tickets.find({}).show(['secret']))[0]).toHaveProperty('secret');
-    const defaultSelection = await tickets.find({}).select();
-    expect(defaultSelection[0]).not.toHaveProperty('secret');
-    expect(await tickets.find({ status: 'open', owner: owner._id })).toHaveLength(2);
-    expect(await tickets.find({ title: 'Missing ticket' }).first()).toBeNull();
-    const populated = await tickets
-      .find({ status: 'open' })
-      .populate([{ ref: 'owner', select: ['name'] }]);
-    expect(populated[0].owner?.name).toBe('Ada');
-    expect(populated[0].owner).toHaveProperty('_id');
-    const populatedCursor = tickets
-      .find({ status: 'open' })
-      .populate([{ ref: 'owner', select: ['name'] }])
-      .limit(1)
-      .cursor();
-    const cursorDocuments = [];
-    for await (const ticket of populatedCursor) cursorDocuments.push(ticket);
-    expect(cursorDocuments[0].owner?.name).toBe('Ada');
-    expect(await tickets.find()).toEqual(await tickets.find({}));
-    expect(await tickets.find({ status: 'open' }).count()).toBe(2);
-    expect(await tickets.find().count(true)).toBeGreaterThanOrEqual(3);
-    await expect(tickets.find({ status: 'open' }).count(true)).rejects.toThrow(
-      'do not support filters',
-    );
-    const firstPage = tickets.find({}).limit(2).cursor();
-    const firstResults = [];
-    for await (const ticket of firstPage) firstResults.push(ticket);
-    expect(firstResults).toHaveLength(2);
-    expect(firstPage.next).toBeInstanceOf(ObjectId);
-    const secondPage = await tickets
-      .find({})
-      .limit(2)
-      .cursor(firstPage.next ?? undefined);
-    const secondResults = [];
-    for await (const ticket of secondPage) secondResults.push(ticket);
-    expect(secondResults).toHaveLength(1);
-    expect(secondPage.next).toBeNull();
-    expect(new Set([...firstResults, ...secondResults].map((ticket) => ticket._id)).size).toBe(3);
-    const projectedPage = tickets.find({}).select(['title']).limit(2).cursor();
-    for await (const ticket of projectedPage) {
-      expect(ticket).toHaveProperty('title');
-      expect(ticket).not.toHaveProperty('secret');
-      expect(ticket).not.toHaveProperty('priority');
-    }
-    const sorted = await tickets.find({ status: 'open' }).sort({ priority: 'desc' });
-    expect(sorted.map((ticket) => ticket.priority)).toEqual([2, 1]);
-    const skipped = await tickets.find({ status: 'open' }).sort({ priority: 'desc' }).skip(1);
-    expect(skipped.map((ticket) => ticket.priority)).toEqual([1]);
-    expect(() => tickets.find({}).skip(-1)).toThrow('non-negative integer');
-    const limited = await tickets.find({ status: 'open' }).sort({ priority: 'desc' }).limit(1);
-    expect(limited.map((ticket) => ticket.priority)).toEqual([2]);
-    expect(() => tickets.find({}).limit(-1)).toThrow('non-negative integer');
-    const invalidCursorQuery = tickets.find({}).limit(3).sort({ priority: 'desc' }).skip(5) as any;
-    expect(() => invalidCursorQuery.cursor()).toThrow('Cursor queries do not support skip');
-    expect(() => tickets.find({}).cursor()).toThrow('Cursor queries require a positive limit');
-    expect(() => (tickets.find({}).limit(3).sort({ priority: 'desc' }).cursor as any)()).toThrow(
-      'default _id ascending sort',
-    );
-    const selected = await tickets.find({ status: 'open' }).select(['title', 'priority']);
-    expect(selected[0]).toMatchObject({ title: 'Design API', priority: 1 });
-    expect(Object.keys(selected[0])).toEqual(expect.arrayContaining(['_id', 'title', 'priority']));
-    const selectedOne = await tickets.find({ title: 'Design API' }).select(['title']).first();
-    expect(selectedOne).toMatchObject({ title: 'Design API' });
-    expect(selectedOne).not.toHaveProperty('priority');
-    expect((await tickets.find({ title: 'Design API' }).first())?._id).toEqual(first._id);
-
-    const updated = await tickets.update({ _id: first._id }, { status: 'closed' });
-    expect(updated).toMatchObject({ title: 'Design API', status: 'closed' });
-
-    const deleted = await tickets.delete({ owner: otherOwner._id });
-    expect(deleted.deletedCount).toBe(1);
-    expect(await tickets.find({})).toHaveLength(2);
-  });
-
-  it('bulk creates validated documents with generated ids', async () => {
-    const owner = await owners.create({ name: 'Grace' });
-    const created = await tickets.bulk.create([
-      {
-        title: 'Bulk one',
-        status: 'open',
-        priority: 1,
-        owner: owner._id,
-        secret: 'first-secret',
-      },
-      {
-        title: 'Bulk two',
-        status: 'closed',
-        priority: 2,
-        owner: owner._id,
-        secret: 'second-secret',
-      },
-    ]);
-
-    expect(created).toHaveLength(2);
-    expect(created[0]._id).toBeInstanceOf(ObjectId);
-    expect(created[0]._id).not.toEqual(created[1]._id);
-    expect(await tickets.find({})).toHaveLength(2);
-    expect((await tickets.find({}).show(['secret']))[1].secret).toBe('second-secret');
-  });
-});

package/tests/model/lifecycle.integration.test.ts

@@ -1,44 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-
-import { createDatabase, orm } from '../../src/index.js';
-import { env } from '../env.js';
-
-const runDatabaseTests = Boolean(env.MONGODB_URI);
-const database = createDatabase({
-  uri: env.MONGODB_URI ?? 'mongodb://127.0.0.1:27017',
-  database: env.MONGODB_DATABASE,
-});
-const lifecycleSchema = orm
-  .schema({ name: orm.string() })
-  .options({ timestamps: true, softdelete: true });
-const lifecycle = database.model('lifecycle', lifecycleSchema);
-
-describe.skipIf(!runDatabaseTests)('model lifecycle', () => {
-  beforeAll(() => database.connect());
-  beforeEach(() => lifecycle.purge({}));
-  afterAll(() => database.disconnect());
-
-  it('manages timestamps and soft deletion', async () => {
-    const first = await lifecycle.create({ name: 'Ada' });
-    const second = await lifecycle.create({ name: 'Alan' });
-
-    expect(first.createdAt).toBeInstanceOf(Date);
-    expect(first.updatedAt).toBeInstanceOf(Date);
-    expect(first.deletedAt).toBeNull();
-    expect(await lifecycle.find({})).toHaveLength(2);
-
-    const deleted = await lifecycle.delete({ _id: first._id });
-    expect(deleted.deletedCount).toBe(1);
-    expect(await lifecycle.find({})).toHaveLength(1);
-    expect(await lifecycle.find({}).deleted('include')).toHaveLength(2);
-    expect((await lifecycle.find({}).deleted('only'))[0]._id).toEqual(first._id);
-
-    const restored = await lifecycle.restore({ _id: first._id });
-    expect(restored?.deletedAt).toBeNull();
-    expect(await lifecycle.find({})).toHaveLength(2);
-
-    const updated = await lifecycle.update({ _id: second._id }, { name: 'Alan Turing' });
-    expect(updated?.name).toBe('Alan Turing');
-    expect(updated?.updatedAt.getTime()).toBeGreaterThanOrEqual(second.updatedAt.getTime());
-  });
-});

package/tests/query/runtime.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { ObjectId, orm } from '../../src/index.js';
-import { createCursorFilter, projectionFor, SoftDeleteState } from '../../src/query/runtime.js';
-import type { ModelFilter } from '../../src/query/types.js';
-
-const fields = {
-  name: orm.string(),
-  profile: orm.object({ city: orm.string(), country: orm.string() }),
-  secret: orm.string().hidden(),
-};
-type Shape = typeof fields;
-
-describe('query runtime policies', () => {
-  it('builds visible projections when selection is empty', () => {
-    expect(projectionFor(['name', 'profile.city', 'secret'], ['secret'], [], [])).toEqual({
-      name: 1,
-      'profile.city': 1,
-    });
-  });
-
-  it('normalizes overlapping selected and shown fields', () => {
-    expect(
-      projectionFor(
-        ['name', 'profile', 'profile.city', 'secret'],
-        ['secret'],
-        ['profile', 'profile.city'],
-        ['secret'],
-      ),
-    ).toEqual({ profile: 1, secret: 1 });
-  });
-
-  it('applies active, deleted, and all soft-delete filters', () => {
-    const filter = { name: 'Ada' } as ModelFilter<Shape>;
-    const state = new SoftDeleteState<Shape>(true);
-
-    expect(state.effectiveFilter(filter)).toEqual({
-      $and: [{ deletedAt: null }, filter],
-    });
-
-    state.deleted('only');
-    expect(state.effectiveFilter(filter)).toEqual({
-      $and: [{ deletedAt: { $ne: null } }, filter],
-    });
-
-    state.includeDeleted();
-    expect(state.effectiveFilter(filter)).toBe(filter);
-  });
-
-  it('adds an id cursor boundary without changing the base filter', () => {
-    const filter = { name: 'Ada' } as ModelFilter<Shape>;
-    const after = new ObjectId();
-
-    expect(createCursorFilter(filter, after)).toEqual({
-      $and: [filter, { _id: { $gt: after } }],
-    });
-    expect(createCursorFilter(filter)).toBe(filter);
-  });
-});

package/tests/relations/definitions.test.ts

@@ -1,36 +0,0 @@
-import { ObjectId } from 'mongodb';
-import { describe, expect, it } from 'vitest';
-
-import { orm } from '../../src/index.js';
-
-describe('relations', () => {
-  it('collects lazy relation metadata without evaluating it during construction', () => {
-    const group = orm.schema({ name: orm.string() });
-    const user = orm.schema({
-      group: orm.ref(() => group).optional(),
-      nullableGroup: orm.ref(() => group).nullable(),
-      nullishGroup: orm.ref(() => group).nullish(),
-    });
-
-    expect(user.refs.group.resolve()).toBe(group);
-    const groupId = new ObjectId();
-    expect(user.parse({ group: groupId, nullableGroup: null, nullishGroup: undefined })).toEqual({
-      group: groupId,
-      nullableGroup: null,
-      nullishGroup: undefined,
-    });
-    expect(() => user.parse({ group: 'group-1' })).toThrow('Invalid input');
-  });
-
-  it('declares one-way relations and population scopes', () => {
-    const group = orm.schema({ name: orm.string() });
-    const user = orm
-      .schema({ name: orm.string(), group: orm.objectId().optional() })
-      .relations({ group: () => group })
-      .scopes({ detail: [{ ref: 'group', select: ['name'] }] });
-
-    expect(user.relationMap.group.resolve()).toBe(group);
-    expect(user.relationMap.group.localField).toBe('group');
-    expect(user.scopeMap.detail).toEqual([{ ref: 'group', select: ['name'] }]);
-  });
-});

package/tests/schema/core.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { orm } from '../../src/index.js';
-
-describe('schema', () => {
-  it('parses a schema definition', () => {
-    const user = orm.schema({ name: orm.string(), age: orm.number() });
-
-    expect(user.parse({ name: 'Ada', age: 36 })).toEqual({ name: 'Ada', age: 36 });
-    expect(user.parsePartial({ age: 37 })).toEqual({ age: 37 });
-    expect(() => user.parsePartial({ age: 'thirty-seven' })).toThrow('Invalid input');
-  });
-
-  it('parses nested object fields', () => {
-    const profile = orm.schema({
-      details: orm.object({
-        website: orm.string().optional(),
-        location: orm.object({ city: orm.string() }),
-      }),
-    });
-
-    expect(
-      profile.parse({ details: { website: 'example.test', location: { city: 'London' } } }),
-    ).toEqual({
-      details: { website: 'example.test', location: { city: 'London' } },
-    });
-  });
-
-  it('preserves hidden metadata through common Zod wrappers', () => {
-    const account = orm.schema({
-      email: orm.string().email(),
-      token: orm.string().optional().hidden(),
-      backupToken: orm.string().nullable().hidden(),
-    });
-
-    expect(account.hiddenFields).toEqual(['token', 'backupToken']);
-    expect(
-      account.parse({ email: 'ada@example.test', token: undefined, backupToken: null }),
-    ).toEqual({
-      email: 'ada@example.test',
-      token: undefined,
-      backupToken: null,
-    });
-  });
-});