Types

TypeScript type definitions exported by Monch.

Import

import type {
  // Schema types
  Schema,
  Doc,
  Input,

  // Collection types
  Collection,
  CollectionConfig,
  CollectionInstance,
  MonchDocument,

  // Query types
  MonchFilter,

  // Timestamp types
  TimestampFields,
  WithTimestamps,
  WithTS,

  // Hook types
  Hooks,

  // Index types
  Index,
  IndexOptions,
  IndexDirection,

  // Connection types
  ConnectionConfig,
  ConnectionResult,
  DebugConfig,
  OperationOptions,

  // Serialization types
  Serialized,
  WithSerialize,

  // Pagination types
  PaginationResult,
  PaginationOptions,

  // Money types
  MoneyValue,
  MoneyOptions,

  // Type extraction
  ModelOf,
  SerializedOf,
  SchemaOf,
} from '@codician-team/monch';

Schema Types

Schema

Schema definition type (record of Zod types):

type Schema = Record<string, ZodType>;

Doc<S>

Document type inferred from schema:

type Doc<S extends Schema> = z.infer<z.ZodObject<S>>;

Input<S>

Input type for insertions (respects defaults/optionals):

type Input<S extends Schema> = z.input<z.ZodObject<S>>;

Collection Types

Collection<T, I, S>

Full collection type with type accessors:

type Collection<T, I, S> = CollectionInstance<T, I> & TypeAccessors<S>;

CollectionInstance<T, I>

Collection instance with all query/mutation operations:

interface CollectionInstance<T, I> {
  find(filter?: MonchFilter<T>): Cursor<T>;
  findOne(filter: MonchFilter<T>): Promise<MonchDocument<T> | null>;
  findById(id: any): Promise<MonchDocument<T> | null>;
  insertOne(doc: I, opts?: OperationOptions): Promise<MonchDocument<T>>;
  // ... all other operations
}

MonchDocument<T>

Document with .serialize() and .toJSON():

type MonchDocument<T> = T & WithSerialize<T>;

CollectionConfig<S, TS>

Configuration for collection():

interface CollectionConfig<S, TS> {
  name: string;
  schema: S;
  uri?: string;
  client?: MongoClient;
  db?: Db;
  database?: string;
  timestamps?: boolean;
  indexes?: Index[];
  createIndexes?: boolean;
  hooks?: Hooks<Doc<S>>;
}

Query Types

MonchFilter<T>

Relaxed filter type for Zod compatibility:

type MonchFilter<T> = Filter<T> | Record<string, any>;

Allows queries without strict type checking on nested paths and operators.

Timestamp Types

TimestampFields

interface TimestampFields {
  createdAt: Date;
  updatedAt: Date;
}

WithTimestamps<T>

Add timestamp fields to a type:

type WithTimestamps<T> = T & TimestampFields;

WithTS<T>

Alias for WithTimestamps:

type WithTS<T> = WithTimestamps<T>;

Hook Types

Hooks<T>

Lifecycle hooks definition:

interface Hooks<T> {
  beforeValidate?: (doc: any) => any | Promise<any>;
  afterValidate?: (doc: T) => T | Promise<T>;
  beforeInsert?: (doc: T) => T | Promise<T>;
  afterInsert?: (doc: T) => void | Promise<void>;
  beforeUpdate?: (filter: any, update: any) => { filter: any; update: any } | Promise<{ filter: any; update: any }>;
  afterUpdate?: (doc: T | null) => void | Promise<void>;
  beforeDelete?: (filter: any) => any | Promise<any>;
  afterDelete?: (count: number) => void | Promise<void>;
}

Index Types

Index

interface Index {
  key: Record<string, IndexDirection>;
  unique?: boolean;
  sparse?: boolean;
  background?: boolean;
  expireAfterSeconds?: number;
  partialFilterExpression?: object;
  name?: string;
  collation?: object;
}

IndexDirection

type IndexDirection = 1 | -1 | 'text' | '2dsphere' | '2d' | 'hashed';

IndexOptions

interface IndexOptions {
  unique?: boolean;
  sparse?: boolean;
  background?: boolean;
  expireAfterSeconds?: number;
  partialFilterExpression?: object;
  name?: string;
  collation?: object;
}

Connection Types

ConnectionConfig

interface ConnectionConfig {
  uri?: string;
  client?: MongoClient;
  db?: Db;
  database?: string;
}

ConnectionResult

interface ConnectionResult {
  client: MongoClient;
  db: Db;
}

DebugConfig

interface DebugConfig {
  enabled: boolean;
  logger?: (operation: string, collection: string, ...args: any[]) => void;
}

OperationOptions

interface OperationOptions {
  session?: ClientSession;
}

Serialization Types

Serialized<T>

Serialized version of a document:

type Serialized<T> = {
  [K in keyof T]: T[K] extends ObjectId ? string
    : T[K] extends Date ? string
    : T[K] extends Long ? number | bigint
    : T[K] extends Decimal128 ? string
    : T[K] extends Binary ? string
    : T[K] extends Timestamp ? { t: number; i: number }
    : T[K] extends object ? Serialized<T[K]>
    : T[K];
};

WithSerialize<T>

Object with .serialize() method:

interface WithSerialize<T> {
  serialize(): Serialized<T>;
}

Pagination Types

PaginationResult<T>

interface PaginationResult<T> {
  data: T[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
    hasNext: boolean;
    hasPrev: boolean;
  };
}

PaginationOptions

interface PaginationOptions {
  page?: number;
  limit?: number;
}

Money Types

MoneyValue

interface MoneyValue {
  amount: Decimal128;  // High-precision decimal
  currency: string;    // Currency code
}

MoneyOptions

interface MoneyOptions {
  currency?: string;      // Currency code (default: 'USD')
  min?: number;           // Minimum amount
  max?: number;           // Maximum amount
  allowNegative?: boolean; // Allow negative amounts (default: false)
}

Type Extraction Helpers

ModelOf<C>

Extract document type from collection:

type ModelOf<C> = C extends Collection<any, any, infer S> ? Doc<S> : never;

SerializedOf<C>

Extract serialized type from collection:

type SerializedOf<C> = C extends Collection<any, any, infer S> ? Serialized<Doc<S>> : never;

SchemaOf<C>

Extract schema type from collection:

type SchemaOf<C> = C extends Collection<any, any, infer S> ? S : never;