modelence 0.6.17 → 0.6.19

package/dist/server.d.ts

@@ -1,496 +1,13 @@
 import { A as AppServer } from './index-CwdohC5n.js';
-import { P as Permission, S as Session, U as UserInfo, C as ConfigSchema, d as ServerChannel, e as User, W as WebsocketServerProvider, R as RoleDefinition, b as ConfigKey, A as AppConfig, f as Role } from './types-CmI2APz9.js';
-import * as mongodb from 'mongodb';
-import { ObjectId as ObjectId$1, WithId, IndexDescription, SearchIndexDescription, MongoClient, Collection, Filter, FindOptions, Document, OptionalUnlessRequiredId, InsertOneResult, InsertManyResult, UpdateFilter, UpdateResult, ClientSession, DeleteResult, AggregateOptions, AggregationCursor, AnyBulkWriteOperation, BulkWriteResult } from 'mongodb';
+import { C as ConfigSchema, S as ServerChannel, U as User, d as Session, W as WebsocketServerProvider, R as RoleDefinition, b as ConfigKey, A as AppConfig, e as UserInfo, f as Role } from './types-Ds1ESQSs.js';
+import { S as Store, M as MethodDefinition, R as RouteDefinition, C as CronJobInputParams, a as RateLimitRule, E as EmailProvider, b as ConnectionInfo, I as InferDocumentType, c as RateLimitType, d as EmailPayload } from './types-D6nwUab6.js';
+export { H as HttpMethod, e as RouteHandler, f as RouteParams, g as RouteResponse, s as schema } from './types-D6nwUab6.js';
+import { ObjectId as ObjectId$1 } from 'mongodb';
 export { ObjectId } from 'mongodb';
 import * as zod from 'zod';
-import { z, ZodNumber, ZodArray } from 'zod';
-import { Request, Response, NextFunction } from 'express';
-import { EmailProvider, EmailPayload } from './types.js';
+import 'express';
 import 'http';
 
-type CronJobHandler = () => Promise<void>;
-type CronJobInputParams = {
-    description?: string;
-    interval: number;
-    timeout?: number;
-    handler: CronJobHandler;
-};
-
-type ObjectTypeDefinition = {
-    [key: string]: SchemaTypeDefinition;
-};
-type SingularSchemaTypeDefinition = z.ZodType | ObjectTypeDefinition;
-type SchemaTypeDefinition = SingularSchemaTypeDefinition | Array<SingularSchemaTypeDefinition>;
-type ModelSchema = {
-    [key: string]: SchemaTypeDefinition;
-};
-type InferDocumentType<T extends SchemaTypeDefinition> = {
-    [K in keyof T as T[K] extends z.ZodOptional<z.ZodTypeAny> ? K : never]?: T[K] extends z.ZodType ? z.infer<T[K]> : never;
-} & {
-    [K in keyof T as T[K] extends z.ZodOptional<z.ZodTypeAny> ? never : K]: T[K] extends z.ZodType ? z.infer<T[K]> : T[K] extends Array<infer ElementType extends SchemaTypeDefinition> ? Array<InferDocumentType<ElementType>> : T[K] extends ObjectTypeDefinition ? InferDocumentType<T[K]> : never;
-};
-declare const schema: {
-    readonly string: (params?: z.RawCreateParams & {
-        coerce?: true;
-    }) => z.ZodString;
-    readonly number: (params?: z.RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodNumber;
-    readonly date: (params?: z.RawCreateParams & {
-        coerce?: boolean;
-    }) => z.ZodDate;
-    readonly boolean: (params?: z.RawCreateParams & {
-        coerce?: boolean;
-    }) => z.ZodBoolean;
-    readonly array: <El extends z.ZodTypeAny>(schema: El, params?: z.RawCreateParams) => ZodArray<El>;
-    readonly object: <Shape extends z.ZodRawShape>(shape: Shape, params?: z.RawCreateParams) => z.ZodObject<Shape, "strip", z.ZodTypeAny, z.objectOutputType<Shape, z.ZodTypeAny, "strip">, z.objectInputType<Shape, z.ZodTypeAny, "strip">>;
-    readonly enum: {
-        <U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: z.RawCreateParams): z.ZodEnum<z.Writeable<T>>;
-        <U extends string, T extends [U, ...U[]]>(values: T, params?: z.RawCreateParams): z.ZodEnum<T>;
-    };
-    readonly embedding: () => ZodArray<ZodNumber>;
-    readonly objectId: () => z.ZodType<ObjectId$1>;
-    readonly userId: () => z.ZodType<ObjectId$1>;
-    readonly ref: <T extends ModelSchema>(_collection: string | Store<T, InferDocumentType<T>>) => z.ZodType<ObjectId$1>;
-    readonly union: <Options extends Readonly<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>>(types: Options, params?: z.RawCreateParams) => z.ZodUnion<Options>;
-    readonly infer: <T extends SchemaTypeDefinition>(_schema: T) => InferDocumentType<T>;
-};
-declare namespace schema {
-    type infer<T extends SchemaTypeDefinition> = InferDocumentType<T>;
-}
-
-interface SerializedModelSchema {
-    [key: string]: SerializedSchema | (SerializedSchema | SerializedModelSchema)[] | SerializedModelSchema | 'v2';
-}
-type BaseSerializedSchema = {
-    type: 'string';
-} | {
-    type: 'number';
-} | {
-    type: 'boolean';
-} | {
-    type: 'date';
-} | {
-    type: 'array';
-    items: SerializedSchema;
-} | {
-    type: 'object';
-    items: Record<string, SerializedSchema>;
-} | {
-    type: 'enum';
-    items: readonly string[];
-} | {
-    type: 'union';
-    items: SerializedSchema[];
-} | {
-    type: 'custom';
-    typeName: string;
-};
-type SerializedSchema = BaseSerializedSchema | (BaseSerializedSchema & {
-    optional: true;
-});
-
-/**
- * Helper type to preserve method types when extending a store.
- * Maps each method to work with the extended schema while preserving signatures.
- * @internal
- */
-type PreserveMethodsForExtendedSchema<TBaseMethods extends Record<string, (...args: never[]) => unknown>, TExtendedSchema extends ModelSchema> = {
-    [K in keyof TBaseMethods]: TBaseMethods[K] extends (this: any, ...args: infer Args) => infer Return ? (this: WithId<InferDocumentType<TExtendedSchema>> & any, ...args: Args) => Return : never;
-};
-/**
- * The Store class provides a type-safe interface for MongoDB collections with built-in schema validation and helper methods.
- *
- * @category Store
- * @typeParam TSchema - The document schema type
- * @typeParam TMethods - Custom methods that will be added to documents
- *
- * @example
- * ```ts
- * const dbTodos = new Store('todos', {
- *   schema: {
- *     title: schema.string(),
- *     completed: schema.boolean(),
- *     dueDate: schema.date().optional(),
- *     userId: schema.userId(),
- *   },
- *   methods: {
- *     isOverdue() {
- *       return this.dueDate < new Date();
- *     }
- *   }
- * });
- * ```
- */
-declare class Store<TSchema extends ModelSchema, TMethods extends Record<string, (this: WithId<InferDocumentType<TSchema>> & TMethods, ...args: any[]) => any>> {
-    /** @internal */
-    readonly _type: InferDocumentType<TSchema>;
-    /** @internal */
-    readonly _rawDoc: WithId<this['_type']>;
-    /** @internal */
-    readonly _doc: this['_rawDoc'] & TMethods;
-    readonly Doc: this['_doc'];
-    private name;
-    private readonly schema;
-    private readonly methods?;
-    private readonly indexes;
-    private readonly searchIndexes;
-    private collection?;
-    private client?;
-    /**
-     * Creates a new Store instance
-     *
-     * @param name - The collection name in MongoDB
-     * @param options - Store configuration
-     */
-    constructor(name: string, options: {
-        /** Document schema using Modelence schema types */
-        schema: TSchema;
-        /** Custom methods to add to documents */
-        methods?: TMethods;
-        /** MongoDB indexes to create */
-        indexes: IndexDescription[];
-        /** MongoDB Atlas Search */
-        searchIndexes?: SearchIndexDescription[];
-    });
-    getName(): string;
-    /** @internal */
-    getSchema(): TSchema;
-    /** @internal */
-    getSerializedSchema(): SerializedModelSchema;
-    /**
-     * Extends the store with additional schema fields, indexes, methods, and search indexes.
-     * Returns a new Store instance with the extended schema and updated types.
-     * Methods from the original store are preserved with updated type signatures.
-     *
-     * @param config - Additional schema fields, indexes, methods, and search indexes to add
-     * @returns A new Store instance with the extended schema
-     *
-     * @example
-     * ```ts
-     * // Extend the users collection
-     * export const dbUsers = baseUsersCollection.extend({
-     *   schema: {
-     *     firstName: schema.string(),
-     *     lastName: schema.string(),
-     *     companyId: schema.objectId().optional(),
-     *   },
-     *   indexes: [
-     *     { key: { companyId: 1 } },
-     *     { key: { lastName: 1, firstName: 1 } },
-     *   ],
-     *   methods: {
-     *     getFullName() {
-     *       return `${this.firstName} ${this.lastName}`;
-     *     }
-     *   }
-     * });
-     *
-     * // Now fully typed with new fields
-     * const user = await dbUsers.findOne({ firstName: 'John' });
-     * console.log(user?.getFullName());
-     * ```
-     */
-    extend<TExtendedSchema extends ModelSchema, TExtendedMethods extends Record<string, (this: WithId<InferDocumentType<TSchema & TExtendedSchema>> & any, ...args: any[]) => any> = Record<string, never>>(config: {
-        schema?: TExtendedSchema;
-        indexes?: IndexDescription[];
-        methods?: TExtendedMethods;
-        searchIndexes?: SearchIndexDescription[];
-    }): Store<TSchema & TExtendedSchema, PreserveMethodsForExtendedSchema<TMethods, TSchema & TExtendedSchema> & TExtendedMethods>;
-    /** @internal */
-    init(client: MongoClient): void;
-    /** @internal */
-    createIndexes(): Promise<void>;
-    private wrapDocument;
-    /**
-     * For convenience, to also allow directy passing a string or ObjectId as the selector
-     */
-    private getSelector;
-    /** @internal */
-    requireCollection(): Collection<this["_type"]>;
-    /** @internal */
-    requireClient(): MongoClient;
-    findOne(query: Filter<this['_type']>, options?: FindOptions): Promise<this["_doc"] | null>;
-    requireOne(query: Filter<this['_type']>, options?: FindOptions, errorHandler?: () => Error): Promise<this['_doc']>;
-    private find;
-    /**
-     * Fetches a single document by its ID
-     *
-     * @param id - The ID of the document to find
-     * @returns The document, or null if not found
-     */
-    findById(id: string | ObjectId$1): Promise<this['_doc'] | null>;
-    /**
-     * Fetches a single document by its ID, or throws an error if not found
-     *
-     * @param id - The ID of the document to find
-     * @param errorHandler - Optional error handler to return a custom error if the document is not found
-     * @returns The document
-     */
-    requireById(id: string | ObjectId$1, errorHandler?: () => Error): Promise<this['_doc']>;
-    /**
-     * Counts the number of documents that match a query
-     *
-     * @param query - The query to filter documents
-     * @returns The number of documents that match the query
-     */
-    countDocuments(query: Filter<this['_type']>): Promise<number>;
-    /**
-     * Fetches multiple documents, equivalent to Node.js MongoDB driver's `find` and `toArray` methods combined.
-     *
-     * @param query - The query to filter documents
-     * @param options - Options
-     * @returns The documents
-     */
-    fetch(query: Filter<this['_type']>, options?: {
-        sort?: Document;
-        limit?: number;
-        skip?: number;
-    }): Promise<this['_doc'][]>;
-    /**
-     * Inserts a single document
-     *
-     * @param document - The document to insert
-     * @returns The result of the insert operation
-     */
-    insertOne(document: OptionalUnlessRequiredId<InferDocumentType<TSchema>>): Promise<InsertOneResult>;
-    /**
-     * Inserts multiple documents
-     *
-     * @param documents - The documents to insert
-     * @returns The result of the insert operation
-     */
-    insertMany(documents: OptionalUnlessRequiredId<InferDocumentType<TSchema>>[]): Promise<InsertManyResult>;
-    /**
-     * Updates a single document
-     *
-     * @param selector - The selector to find the document to update
-     * @param update - The update to apply to the document
-     * @returns The result of the update operation
-     */
-    updateOne(selector: Filter<this['_type']> | string | ObjectId$1, update: UpdateFilter<this['_type']>): Promise<UpdateResult>;
-    /**
-     * Updates a single document, or inserts it if it doesn't exist
-     *
-     * @param selector - The selector to find the document to update
-     * @param update - The MongoDB modifier to apply to the document
-     * @returns The result of the update operation
-     */
-    upsertOne(selector: Filter<this['_type']> | string | ObjectId$1, update: UpdateFilter<this['_type']>): Promise<UpdateResult>;
-    /**
-     * Updates multiple documents
-     *
-     * @param selector - The selector to find the documents to update
-     * @param update - The MongoDB modifier to apply to the documents
-     * @returns The result of the update operation
-     */
-    updateMany(selector: Filter<this['_type']>, update: UpdateFilter<this['_type']>, options?: {
-        session?: ClientSession;
-    }): Promise<UpdateResult>;
-    /**
-     * Updates multiple documents, or inserts them if they don't exist
-     *
-     * @param selector - The selector to find the documents to update
-     * @param update - The MongoDB modifier to apply to the documents
-     * @returns The result of the update operation
-     */
-    upsertMany(selector: Filter<this['_type']>, update: UpdateFilter<this['_type']>): Promise<UpdateResult>;
-    /**
-     * Deletes a single document
-     *
-     * @param selector - The selector to find the document to delete
-     * @returns The result of the delete operation
-     */
-    deleteOne(selector: Filter<this['_type']>): Promise<DeleteResult>;
-    /**
-     * Deletes multiple documents
-     *
-     * @param selector - The selector to find the documents to delete
-     * @returns The result of the delete operation
-     */
-    deleteMany(selector: Filter<this['_type']>): Promise<DeleteResult>;
-    /**
-     * Aggregates documents using MongoDB's aggregation framework
-     *
-     * @param pipeline - The aggregation pipeline
-     * @param options - Optional options
-     * @returns The aggregation cursor
-     */
-    aggregate(pipeline: Document[], options?: AggregateOptions): AggregationCursor<Document>;
-    /**
-     * Performs a bulk write operation on the collection
-     *
-     * @param operations - The operations to perform
-     * @returns The result of the bulk write operation
-     */
-    bulkWrite(operations: AnyBulkWriteOperation<this['_type']>[]): Promise<BulkWriteResult>;
-    /**
-     * Returns the raw MongoDB database instance for advanced operations
-     * @returns The MongoDB database instance
-     * @throws Error if the store is not provisioned
-     */
-    getDatabase(): mongodb.Db;
-    /**
-     * Returns the raw MongoDB collection instance for advanced operations
-     * @returns The MongoDB collection instance
-     * @throws Error if the store is not provisioned
-     */
-    rawCollection(): Collection<this["_type"]>;
-    /**
-     * Renames an existing collection to this store's name, used for migrations
-     * @param oldName - The previous name of the collection
-     * @throws Error if the old collection doesn't exist or if this store's collection already exists
-     */
-    renameFrom(oldName: string, options?: {
-        session?: ClientSession;
-    }): Promise<void>;
-    /**
-     * Performs a vector similarity search using MongoDB Atlas Vector Search
-     *
-     * @param params - Vector search parameters
-     * @param params.field - The field name containing the vector embeddings
-     * @param params.embedding - The query vector to search for
-     * @param params.numCandidates - Number of nearest neighbors to consider (default: 100)
-     * @param params.limit - Maximum number of results to return (default: 10)
-     * @param params.projection - Additional fields to include in the results
-     * @param params.indexName - Name of index (default: field + VectorSearch)
-     * @returns An aggregation cursor with search results and scores
-     *
-     * @example
-     * ```ts
-     * const results = await store.vectorSearch({
-     *   field: 'embedding',
-     *   embedding: [0.1, 0.2, 0.3, ...],
-     *   numCandidates: 100,
-     *   limit: 10,
-     *   projection: { title: 1, description: 1 }
-     * });
-     * ```
-     */
-    vectorSearch({ field, embedding, numCandidates, limit, projection, indexName, }: {
-        field: string;
-        embedding: number[];
-        numCandidates?: number;
-        limit?: number;
-        projection?: Document;
-        indexName?: string;
-    }): Promise<AggregationCursor<Document>>;
-    /**
-     * Creates a MongoDB Atlas Vector Search index definition
-     *
-     * @param params - Vector index parameters
-     * @param params.field - The field name to create the vector index on
-     * @param params.dimensions - The number of dimensions in the vector embeddings
-     * @param params.similarity - The similarity metric to use (default: 'cosine')
-     * @param params.indexName - Name of index (default: field + VectorSearch)
-     * @returns A search index description object
-     *
-     * @example
-     * ```ts
-     * const store = new Store('documents', {
-     *   schema: {
-     *     title: schema.string(),
-     *     embedding: schema.array(schema.number()),
-     *   },
-     *   indexes: [],
-     *   searchIndexes: [
-     *     Store.vectorIndex({
-     *       field: 'embedding',
-     *       dimensions: 1536,
-     *       similarity: 'cosine'
-     *     })
-     *   ]
-     * });
-     * ```
-     */
-    static vectorIndex({ field, dimensions, similarity, indexName, }: {
-        field: string;
-        dimensions: number;
-        similarity?: 'cosine' | 'euclidean' | 'dotProduct';
-        indexName?: string;
-    }): {
-        type: string;
-        name: string;
-        definition: {
-            fields: {
-                type: string;
-                path: string;
-                numDimensions: number;
-                similarity: "cosine" | "euclidean" | "dotProduct";
-            }[];
-        };
-    };
-}
-
-type ClientInfo = {
-    screenWidth: number;
-    screenHeight: number;
-    windowWidth: number;
-    windowHeight: number;
-    pixelRatio: number;
-    orientation: string | null;
-};
-type ConnectionInfo = {
-    ip?: string;
-    userAgent?: string;
-    acceptLanguage?: string;
-    referrer?: string;
-    baseUrl?: string;
-};
-type Context = {
-    session: Session | null;
-    user: UserInfo | null;
-    roles: string[];
-    clientInfo: ClientInfo;
-    connectionInfo: ConnectionInfo;
-};
-type Args = Record<string, unknown>;
-type Handler<T = unknown> = (args: Args, context: Context) => Promise<T> | T;
-type MethodDefinition<T = unknown> = {
-    permissions?: Permission[];
-    handler: Handler<T>;
-} | Handler<T>;
-
-type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head' | 'all' | 'use';
-type RouteParams<T = unknown> = {
-    query: Record<string, string>;
-    body: T;
-    params: Record<string, string>;
-    headers: Record<string, string>;
-    cookies: Record<string, string>;
-    req: Request;
-    res: Response;
-    next: NextFunction;
-};
-type RouteResponse<T = unknown> = {
-    data?: T;
-    status?: number;
-    headers?: Record<string, string>;
-    redirect?: string;
-} | null;
-type RouteHandler<T = unknown> = (params: RouteParams, context: Pick<Context, 'session' | 'user'>) => Promise<RouteResponse<T>> | RouteResponse<T>;
-type RouteHandlers = {
-    [key in HttpMethod]?: RouteHandler;
-};
-type RouteDefinition = {
-    path: string;
-    handlers: RouteHandlers;
-    errorHandler?: RouteHandler;
-};
-
-type RateLimitType = 'ip' | 'user';
-type RateLimitRule = {
-    /** Logical action being limited, e.g. "signup" */
-    bucket: string;
-    /** Identifier type of the actor this rule applies to */
-    type: RateLimitType;
-    /** Time window size in milliseconds */
-    window: number;
-    /** Maximum allowed hits within the window */
-    limit: number;
-};
-
 /** Array of Store instances that will be provisioned when the module is loaded */
 type Stores = Store<any, any>[];
 /** Record of query methods that can be called from the client */
@@ -563,7 +80,7 @@ declare class Module {
 type MigrationScript = {
     version: number;
     description: string;
-    handler: () => Promise<void>;
+    handler: () => Promise<string | void>;
 };
 
 type EmailConfig = {
@@ -834,7 +351,10 @@ declare const usersCollection: Store<{
         address: string;
         verified: boolean;
     }>, "many">>;
+    status: zod.ZodOptional<zod.ZodEnum<["active", "disabled", "deleted"]>>;
     createdAt: zod.ZodDate;
+    disabledAt: zod.ZodOptional<zod.ZodDate>;
+    deletedAt: zod.ZodOptional<zod.ZodDate>;
     roles: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
     authMethods: zod.ZodObject<{
         password: zod.ZodOptional<zod.ZodObject<{
@@ -891,7 +411,10 @@ declare const usersCollection: Store<{
         address: string;
         verified: boolean;
     }>, "many">>;
+    status: zod.ZodOptional<zod.ZodEnum<["active", "disabled", "deleted"]>>;
     createdAt: zod.ZodDate;
+    disabledAt: zod.ZodOptional<zod.ZodDate>;
+    deletedAt: zod.ZodOptional<zod.ZodDate>;
     roles: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
     authMethods: zod.ZodObject<{
         password: zod.ZodOptional<zod.ZodObject<{
@@ -936,10 +459,13 @@ declare const usersCollection: Store<{
             id: string;
         } | undefined;
     }>;
-}>, "handle" | "roles" | "createdAt" | "emails" | "authMethods"> & {
+}>, "handle" | "roles" | "status" | "createdAt" | "emails" | "disabledAt" | "deletedAt" | "authMethods"> & {
     _id: ObjectId;
 }, ...args: any[]) => any>>;
 
+declare function disableUser(userId: ObjectId$1): Promise<void>;
+declare function deleteUser(userId: ObjectId$1): Promise<void>;
+
 /**
  * This function will check all rate limit rules on the specified bucket and type,
  * throw an error if any of them are exceeded and increase the count of the rate limit record.
@@ -1026,4 +552,4 @@ declare function authenticate(authToken: string | null): Promise<{
 
 declare function sendEmail(payload: EmailPayload): Promise<void> | undefined;
 
-export { type AppOptions, type AuthConfig, type AuthOption, type CloudBackendConnectResponse, type CronJobInputParams, type HttpMethod, Module, type RateLimitRule, type RateLimitType, type RouteDefinition, type RouteHandler, type RouteParams, type RouteResponse, ServerChannel, Store, UserInfo, authenticate, consumeRateLimit, createQuery, usersCollection as dbUsers, getConfig, schema, sendEmail, startApp };
+export { type AppOptions, type AuthConfig, type AuthOption, type CloudBackendConnectResponse, CronJobInputParams, Module, RateLimitRule, RateLimitType, RouteDefinition, ServerChannel, Store, UserInfo, authenticate, consumeRateLimit, createQuery, usersCollection as dbUsers, deleteUser, disableUser, getConfig, sendEmail, startApp };