modelence 0.9.0-dev.0 → 0.9.1

package/dist/telemetry.d.ts

@@ -1,2 +1,11 @@
-export { startTransaction, captureError, logInfo, logError, logDebug } from './telemetry/index';
-//# sourceMappingURL=telemetry.d.ts.map
+declare function logDebug(message: string, args: object): void;
+declare function logInfo(message: string, args: object): void;
+declare function logError(message: string, args: object): void;
+interface WrappedTransaction {
+    end(result?: string, context?: Record<string, unknown>): void;
+    setContext(context: Record<string, unknown>): void;
+}
+declare function startTransaction(type: 'method' | 'cron' | 'ai' | 'custom' | 'route', name: string, context?: Record<string, unknown>): WrappedTransaction;
+declare function captureError(error: Error): void;
+
+export { captureError, logDebug, logError, logInfo, startTransaction };

package/dist/telemetry.js

@@ -1,2 +1,2 @@
-export { startTransaction, captureError, logInfo, logError, logDebug } from './telemetry/index';
+export{l as captureError,h as logDebug,j as logError,i as logInfo,k as startTransaction}from'./chunk-PB6WQQ4L.js';//# sourceMappingURL=telemetry.js.map
 //# sourceMappingURL=telemetry.js.map

package/dist/telemetry.js.map

@@ -1 +1 @@
-{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"telemetry.js"}

package/dist/types-BOFsm7A2.d.ts

@@ -0,0 +1,155 @@
+import { Server } from 'http';
+import { Document, ObjectId } from 'mongodb';
+
+type ConfigType = 'text' | 'string' | 'number' | 'boolean' | 'secret';
+type ConfigKey = string;
+type ConfigParams = {
+    type: ConfigType;
+    default: ValueType<ConfigType>;
+    isPublic: boolean;
+};
+type AppConfig = {
+    key: ConfigKey;
+    value: ValueType<ConfigType>;
+    type: ConfigType;
+};
+type ConfigSchema = {
+    [key: string]: ConfigParams;
+};
+type Configs = Record<ConfigKey, AppConfig>;
+type ValueType<T> = T extends 'number' ? number : T extends 'string' ? string : T extends 'text' ? string : T extends 'boolean' ? boolean : T extends 'secret' ? string : never;
+
+type User = Document;
+type UserInfo = {
+    id: string;
+    handle: string;
+    roles: string[];
+    hasRole: (role: string) => boolean;
+    requireRole: (role: string) => void;
+};
+type Role = string;
+type DefaultRoles = Record<'authenticated' | 'unauthenticated', Role | null>;
+type Session = {
+    authToken: string;
+    expiresAt: Date;
+    userId: ObjectId | null;
+};
+type Permission = string;
+type RoleDefinition = {
+    description?: string;
+    permissions: Permission[];
+};
+type AuthProvider = 'google' | 'github' | 'email';
+type AuthSuccessProps = {
+    provider: AuthProvider;
+    user: User;
+    session: Session | null;
+    connectionInfo: ConnectionInfo;
+};
+type AuthErrorProps = {
+    provider: AuthProvider;
+    error: Error;
+    session: Session | null;
+    connectionInfo: ConnectionInfo;
+};
+
+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 MethodType = 'query' | 'mutation';
+type MethodDefinition<T = unknown> = {
+    permissions?: Permission[];
+    handler: Handler<T>;
+} | Handler<T>;
+type Method<T = unknown> = {
+    type: MethodType;
+    name: string;
+    permissions: Permission[];
+    handler: Handler<T>;
+};
+
+type canAccessChannel = (props: {
+    user: User | null;
+    session: Session | null;
+    roles: string[];
+}) => Promise<boolean>;
+declare class ServerChannel<T = unknown> {
+    readonly category: string;
+    readonly canAccessChannel: canAccessChannel | null;
+    constructor(category: string, canAccessChannel?: canAccessChannel);
+    broadcast(id: string, data: T): void;
+}
+
+declare class ClientChannel<T = unknown> {
+    readonly category: string;
+    private readonly onMessage;
+    constructor(category: string, onMessage: (data: T) => void);
+    init(): void;
+    joinChannel(id: string): void;
+    leaveChannel(id: string): void;
+}
+
+interface WebsocketServerProvider {
+    init(props: {
+        httpServer: Server;
+        channels: ServerChannel[];
+    }): Promise<void>;
+    broadcast<T>(props: {
+        category: string;
+        id: string;
+        data: T;
+    }): void;
+}
+interface WebsocketClientProvider {
+    init(props: {
+        channels?: ClientChannel[];
+    }): void;
+    on<T>(props: {
+        category: string;
+        listener: (data: T) => void;
+    }): void;
+    once<T>(props: {
+        category: string;
+        listener: (data: T) => void;
+    }): void;
+    off<T>(props: {
+        category: string;
+        listener: (data: T) => void;
+    }): void;
+    emit(props: {
+        eventName: string;
+        category: string;
+        id: string;
+    }): void;
+    joinChannel(props: {
+        category: string;
+        id: string;
+    }): void;
+    leaveChannel(props: {
+        category: string;
+        id: string;
+    }): void;
+}
+
+export { type AuthSuccessProps as A, type ConfigSchema as C, type DefaultRoles as D, type Handler as H, type MethodDefinition as M, type Permission as P, type RoleDefinition as R, ServerChannel as S, type User as U, type WebsocketServerProvider as W, type WebsocketClientProvider as a, type ConfigKey as b, ClientChannel as c, type AuthErrorProps as d, type AppConfig as e, type Session as f, type UserInfo as g, type Role as h, type Context as i, type ClientInfo as j, type ConnectionInfo as k, type Args as l, type MethodType as m, type Method as n, type ConfigType as o, type Configs as p, type AuthProvider as q };

package/dist/{data/store.d.ts → types-V9eDnP35.d.ts}

@@ -1,10 +1,106 @@
-import { AggregateOptions, AggregationCursor, Collection, DeleteResult, Document, IndexDescription, InsertOneResult, MongoClient, UpdateResult, WithId, OptionalUnlessRequiredId, FindOptions, UpdateFilter, ObjectId, BulkWriteResult, AnyBulkWriteOperation, InsertManyResult, ClientSession, SearchIndexDescription, FilterOperators } from 'mongodb';
-import { ModelSchema, InferDocumentType } from './types';
-/**
- * Helper type to match strings containing dots (for MongoDB dot notation)
- * @internal
- */
-type DottedString = `${string}.${string}`;
+import './index-CwdohC5n.js';
+import { i as Context } from './types-BOFsm7A2.js';
+import * as mongodb from 'mongodb';
+import { WithId, IndexDescription, SearchIndexDescription, MongoClient, Collection, FilterOperators, Document, FindOptions, ObjectId, OptionalUnlessRequiredId, InsertOneResult, InsertManyResult, UpdateFilter, UpdateResult, ClientSession, DeleteResult, AggregateOptions, AggregationCursor, AnyBulkWriteOperation, BulkWriteResult } from 'mongodb';
+import { z, ZodNumber, ZodArray } from 'zod';
+import { Request, Response, NextFunction } from 'express';
+
+type EmailAttachment = {
+    filename: string;
+    content: Buffer | string;
+    contentType: string;
+};
+type EmailPayload = {
+    from: string;
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string | string[];
+    headers?: Record<string, string>;
+    attachments?: EmailAttachment[];
+} & ({
+    html: string;
+} | {
+    text: string;
+});
+interface EmailProvider {
+    sendEmail(data: EmailPayload): Promise<void>;
+}
+
+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;
+};
+
+type CronJobHandler = () => Promise<void>;
+type CronJob = {
+    alias: string;
+    params: {
+        description: string;
+        interval: number;
+        timeout: number;
+    };
+    handler: CronJobHandler;
+    state: {
+        startTs?: number;
+        scheduledRunTs?: number;
+        isRunning: boolean;
+    };
+};
+type CronJobInputParams = {
+    description?: string;
+    interval: number;
+    timeout?: number;
+    handler: CronJobHandler;
+};
+type CronJobMetadata = {
+    alias: string;
+    description: string;
+    interval: number;
+    timeout: number;
+};
+
+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;
+});
+
 /**
  * Top-level query operators (logical and evaluation) - custom version without Document index signature
  * Based on MongoDB's RootFilterOperators but without the [key: string]: any from Document
@@ -26,6 +122,38 @@ type StrictRootFilterOperators<TSchema> = {
     $expr?: any;
     $jsonSchema?: any;
 };
+/**
+ * Helper type to extract array element type
+ * @internal
+ */
+type ArrayElement<T> = T extends (infer E)[] ? E : never;
+/**
+ * Helper type for $in/$nin that accepts any array/tuple where elements are assignable to T
+ * This solves the issue where TypeScript infers ['a', 'b'] as a tuple instead of ('a' | 'b')[]
+ * and where Array<Union> gets distributed into Union1[] | Union2[] | ...
+ * We wrap the Exclude in a tuple check to prevent distribution
+ * @internal
+ */
+type NonUndefined<T> = T extends undefined ? never : T;
+type ArrayLikeOfUnion<T> = [NonUndefined<T>] extends [never] ? never : ReadonlyArray<NonUndefined<T>> | Array<NonUndefined<T>>;
+/**
+ * Enhanced FilterOperators that fixes $in and $nin to properly accept arrays of union types
+ * MongoDB's native FilterOperators has issues with union types in $in/$nin arrays
+ * because TypeScript distributes Array<Union> into Array1 | Array2 | ...
+ * @internal
+ */
+type EnhancedFilterOperators<T> = Omit<FilterOperators<T>, '$in' | '$nin'> & {
+    $in?: ArrayLikeOfUnion<T>;
+    $nin?: ArrayLikeOfUnion<T>;
+};
+/**
+ * Custom filter value type that handles array fields specially:
+ * - For array fields: allows element type, full array type, or FilterOperators
+ * - For non-array fields: allows exact type or FilterOperators
+ * We use [T] to prevent distribution when T is a union type
+ * @internal
+ */
+type FilterValue<T> = [T] extends [unknown[]] ? ArrayElement<T> | T | EnhancedFilterOperators<T> : [T] extends [never] ? never : T | EnhancedFilterOperators<[T] extends [never] ? never : T>;
 /**
  * Type-safe MongoDB filter that ensures only schema fields can be queried
  * while supporting all MongoDB query operators and dot notation for nested fields.
@@ -33,6 +161,7 @@ type StrictRootFilterOperators<TSchema> = {
  * This type combines:
  * - MongoDB's native `FilterOperators<T>` for field-level operators (comprehensive operator support)
  * - Custom `StrictRootFilterOperators<T>` for top-level operators without index signature
+ * - Custom array field handling: allows passing single element when field is an array
  * - Custom restriction: only strings containing dots are allowed for nested field queries
  *
  * @example
@@ -42,6 +171,7 @@ type StrictRootFilterOperators<TSchema> = {
  *     name: schema.string(),
  *     age: schema.number(),
  *     tags: schema.array(schema.string()),
+ *     collections: schema.array(schema.string()),
  *     address: schema.object({
  *       street: schema.string(),
  *       city: schema.string(),
@@ -58,6 +188,9 @@ type StrictRootFilterOperators<TSchema> = {
  * await dbUsers.findOne({ tags: { $in: ['typescript', 'mongodb'] } });
  * await dbUsers.findOne({ $or: [{ name: 'John' }, { name: 'Jane' }] });
  *
+ * // ✅ Valid - array field with single element (checks if array contains the element)
+ * await dbUsers.findOne({ collections: 'users' });
+ *
  * // ✅ Valid - dot notation for nested fields (must contain a dot)
  * await dbUsers.findOne({ 'address.city': 'New York' });
  * await dbUsers.findOne({ 'emails.0.address': 'test@example.com' });
@@ -66,10 +199,10 @@ type StrictRootFilterOperators<TSchema> = {
  * await dbUsers.findOne({ id: '123' });
  * ```
  */
-export type TypedFilter<T> = {
-    [K in keyof WithId<T>]?: WithId<T>[K] | FilterOperators<WithId<T>[K]>;
+type TypedFilter<T> = {
+    [K in keyof WithId<T>]?: FilterValue<WithId<T>[K]>;
 } & StrictRootFilterOperators<T> & {
-    [K: DottedString]: any;
+    [K: `${string}.${string}`]: any;
 };
 /**
  * Helper type to preserve method types when extending a store.
@@ -103,7 +236,7 @@ type PreserveMethodsForExtendedSchema<TBaseMethods extends Record<string, (...ar
  * });
  * ```
  */
-export declare class Store<TSchema extends ModelSchema, TMethods extends Record<string, (this: WithId<InferDocumentType<TSchema>> & TMethods, ...args: any[]) => any>> {
+declare class Store<TSchema extends ModelSchema, TMethods extends Record<string, (this: WithId<InferDocumentType<TSchema>> & TMethods, ...args: any[]) => any>> {
     /** @internal */
     readonly _type: InferDocumentType<TSchema>;
     /** @internal */
@@ -138,7 +271,7 @@ export declare class Store<TSchema extends ModelSchema, TMethods extends Record<
     /** @internal */
     getSchema(): TSchema;
     /** @internal */
-    getSerializedSchema(): import("./schemaSerializer").SerializedModelSchema;
+    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.
@@ -331,7 +464,7 @@ export declare class Store<TSchema extends ModelSchema, TMethods extends Record<
      * @returns The MongoDB database instance
      * @throws Error if the store is not provisioned
      */
-    getDatabase(): import("mongodb").Db;
+    getDatabase(): mongodb.Db;
     /**
      * Returns the raw MongoDB collection instance for advanced operations
      * @returns The MongoDB collection instance
@@ -423,5 +556,91 @@ export declare class Store<TSchema extends ModelSchema, TMethods extends Record<
         };
     };
 }
-export {};
-//# sourceMappingURL=store.d.ts.map
+
+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>;
+    readonly userId: () => z.ZodType<ObjectId>;
+    readonly ref: <T extends ModelSchema>(_collection: string | Store<T, InferDocumentType<T>>) => z.ZodType<ObjectId>;
+    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>;
+}
+
+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>;
+    rawBody?: Buffer;
+    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 BodyConfig = {
+    json?: boolean | {
+        limit?: string;
+    };
+    urlencoded?: boolean | {
+        limit?: string;
+        extended?: boolean;
+    };
+    raw?: boolean | {
+        limit?: string;
+        type?: string | string[];
+    };
+};
+type RouteDefinition = {
+    path: string;
+    handlers: RouteHandlers;
+    errorHandler?: RouteHandler;
+    body?: BodyConfig;
+};
+type ExpressHandler = (req: Request, res: Response) => Promise<void> | void;
+
+export { type BodyConfig as B, type CronJobInputParams as C, type EmailProvider as E, type HttpMethod as H, type InferDocumentType as I, type ModelSchema as M, type RouteDefinition as R, Store as S, type RateLimitRule as a, type RateLimitType as b, type EmailPayload as c, type RouteHandler as d, type RouteParams as e, type RouteResponse as f, type EmailAttachment as g, type CronJob as h, type CronJobMetadata as i, type RouteHandlers as j, type ExpressHandler as k, schema as s };

package/dist/types.d.ts

@@ -1,10 +1,7 @@
-export type * from './types/index';
-export type * from './methods/types';
-export type * from './rate-limit/types';
-export type * from './cron/types';
-export type * from './config/types';
-export type * from './websocket/types';
-export type * from './data/types';
-export type * from './auth/types';
-export type * from './routes/types';
-//# sourceMappingURL=types.d.ts.map
+export { A as AppServer, E as ExpressMiddleware, M as ModelenceConfig } from './index-CwdohC5n.js';
+export { e as AppConfig, l as Args, d as AuthErrorProps, q as AuthProvider, A as AuthSuccessProps, j as ClientInfo, b as ConfigKey, C as ConfigSchema, o as ConfigType, p as Configs, k as ConnectionInfo, i as Context, D as DefaultRoles, H as Handler, n as Method, M as MethodDefinition, m as MethodType, P as Permission, h as Role, R as RoleDefinition, f as Session, U as User, g as UserInfo, a as WebsocketClientProvider, W as WebsocketServerProvider } from './types-BOFsm7A2.js';
+export { B as BodyConfig, h as CronJob, C as CronJobInputParams, i as CronJobMetadata, g as EmailAttachment, c as EmailPayload, E as EmailProvider, k as ExpressHandler, H as HttpMethod, I as InferDocumentType, M as ModelSchema, a as RateLimitRule, b as RateLimitType, R as RouteDefinition, d as RouteHandler, j as RouteHandlers, e as RouteParams, f as RouteResponse, s as schema } from './types-V9eDnP35.js';
+import 'express';
+import 'http';
+import 'mongodb';
+import 'zod';

package/dist/types.js

@@ -1,2 +1,2 @@
-export {};
+import'./chunk-55J6XMHW.js';//# sourceMappingURL=types.js.map
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "modelence",
-  "version": "0.9.0-dev.0",
+  "version": "0.9.1",
   "description": "The Node.js Framework for Real-Time MongoDB Apps",
   "main": "dist/index.js",
   "types": "dist/global.d.ts",
@@ -24,8 +24,8 @@
     "modelence": "./dist/bin/modelence.js"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc && tsc-alias",
-    "dev": "tsc --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,css,md}\"",
     "format:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx,json,css,md}\"",
     "lint": "eslint src --ext .ts,.tsx --fix",
@@ -48,6 +48,7 @@
   "homepage": "https://modelence.com",
   "devDependencies": {
     "@types/archiver": "^6.0.3",
+    "@types/bcrypt": "^5.0.2",
     "@types/cookie-parser": "^1.4.9",
     "@types/express": "^5.0.0",
     "@types/fs-extra": "^11.0.4",
@@ -64,13 +65,13 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "ts-jest": "^29.4.5",
-    "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.16"
+    "ts-node": "^10.9.2"
   },
   "dependencies": {
     "@socket.io/mongo-adapter": "^0.4.0",
     "@vitejs/plugin-react": "^4.3.4",
     "archiver": "^7.0.1",
+    "bcrypt": "^5.1.1",
     "commander": "^12.0.0",
     "cookie-parser": "^1.4.7",
     "dotenv": "^16.4.5",

package/dist/app/authConfig.d.ts

@@ -1,68 +0,0 @@
-import { Session, User } from '../auth/types';
-import { ConnectionInfo } from '../methods/types';
-/**
- * Callback options for authentication operations
- */
-export type AuthOption = {
-    /** Callback executed when authentication succeeds */
-    onSuccess?: (user: User) => void;
-    /** Callback executed when authentication fails */
-    onError?: (error: Error) => void;
-};
-/**
- * Authentication configuration for the application
- *
- * @example
- * ```typescript
- * import { startApp } from 'modelence/server';
- *
- * startApp({
- *   auth: {
- *     onAfterLogin: ({ user }) => {
- *       console.log('User logged in:', user.name);
- *       // Redirect to dashboard
- *     },
- *     onLoginError: ({ error }) => {
- *       console.error('Login failed:', error.message);
- *       // Show error toast
- *     },
- *     onAfterSignup: ({ user }) => {
- *       console.log('User signed up:', user.email);
- *       // Send welcome email
- *     },
- *     onSignupError: ({ error }) => {
- *       console.error('Signup failed:', error.message);
- *     }
- *   }
- * });
- * ```
- */
-export type AuthConfig = {
-    onAfterLogin?: (props: {
-        user: User;
-        session: Session | null;
-        connectionInfo: ConnectionInfo;
-    }) => void;
-    onLoginError?: (props: {
-        error: Error;
-        session: Session | null;
-        connectionInfo: ConnectionInfo;
-    }) => void;
-    onAfterSignup?: (props: {
-        user: User;
-        session: Session | null;
-        connectionInfo: ConnectionInfo;
-    }) => void;
-    onSignupError?: (props: {
-        error: Error;
-        session: Session | null;
-        connectionInfo: ConnectionInfo;
-    }) => void;
-    /** deprecated: use onAfterLogin and onLoginError */
-    login?: AuthOption;
-    /** deprecated: user onAfterSignup and onSignupError */
-    signup?: AuthOption;
-};
-export declare function setAuthConfig(newAuthConfig: AuthConfig): void;
-export declare function getAuthConfig(): AuthConfig;
-//# sourceMappingURL=authConfig.d.ts.map

package/dist/app/authConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authConfig.d.ts","sourceRoot":"","sources":["../../src/app/authConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACjC,kDAAkD;IAClD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE;QACrB,IAAI,EAAE,IAAI,CAAC;QACX,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;QACxB,cAAc,EAAE,cAAc,CAAC;KAChC,KAAK,IAAI,CAAC;IACX,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE;QACrB,KAAK,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;QACxB,cAAc,EAAE,cAAc,CAAC;KAChC,KAAK,IAAI,CAAC;IACX,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QACtB,IAAI,EAAE,IAAI,CAAC;QACX,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;QACxB,cAAc,EAAE,cAAc,CAAC;KAChC,KAAK,IAAI,CAAC;IACX,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QACtB,KAAK,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;QACxB,cAAc,EAAE,cAAc,CAAC;KAChC,KAAK,IAAI,CAAC;IAEX,oDAAoD;IACpD,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,uDAAuD;IACvD,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB,CAAC;AAIF,wBAAgB,aAAa,CAAC,aAAa,EAAE,UAAU,QAEtD;AAED,wBAAgB,aAAa,eAE5B"}

package/dist/app/authConfig.js

@@ -1,8 +0,0 @@
-let authConfig = Object.freeze({});
-export function setAuthConfig(newAuthConfig) {
-    authConfig = Object.freeze(Object.assign({}, authConfig, newAuthConfig));
-}
-export function getAuthConfig() {
-    return authConfig;
-}
-//# sourceMappingURL=authConfig.js.map

package/dist/app/authConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"authConfig.js","sourceRoot":"","sources":["../../src/app/authConfig.ts"],"names":[],"mappings":"AAqEA,IAAI,UAAU,GAAe,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAE/C,MAAM,UAAU,aAAa,CAAC,aAAyB;IACrD,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC;AAC3E,CAAC;AAED,MAAM,UAAU,aAAa;IAC3B,OAAO,UAAU,CAAC;AACpB,CAAC"}