modelence 0.9.0-dev.0 → 0.9.1

package/dist/index.js

@@ -1,3 +1,2 @@
-export { time } from './time';
-export { AuthError, ValidationError, RateLimitError } from './error';
+export{b as AuthError,d as RateLimitError,c as ValidationError}from'./chunk-C3UESBRX.js';export{a as time}from'./chunk-DO5TZLF5.js';import'./chunk-55J6XMHW.js';//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/mongo.d.ts

@@ -1,4 +1,5 @@
 export { ClientSession, ObjectId } from 'mongodb';
+
 declare const _default: {};
-export default _default;
-//# sourceMappingURL=mongo.d.ts.map
+
+export { _default as default };

package/dist/mongo.js

@@ -1,3 +1,2 @@
-export { ClientSession, ObjectId } from 'mongodb';
-export default {};
+export{ClientSession,ObjectId}from'mongodb';var e={};export{e as default};//# sourceMappingURL=mongo.js.map
 //# sourceMappingURL=mongo.js.map

package/dist/mongo.js.map

@@ -1 +1 @@
-{"version":3,"file":"mongo.js","sourceRoot":"","sources":["../src/mongo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElD,eAAe,EAAE,CAAC"}
+{"version":3,"sources":["../src/mongo.ts"],"names":["mongo_default"],"mappings":"4CAEA,IAAOA,EAAQ","file":"mongo.js","sourcesContent":["export { ClientSession, ObjectId } from 'mongodb';\n\nexport default {};\n"]}

package/dist/package-PESFLDOK.js

@@ -0,0 +1,2 @@
+export{l as author,i as bin,n as bugs,s as default,q as dependencies,d as description,p as devDependencies,g as exports,h as files,o as homepage,m as license,e as main,b as name,r as peerDependencies,k as repository,j as scripts,a as type,f as types,c as version}from'./chunk-EAKMFYSK.js';//# sourceMappingURL=package-PESFLDOK.js.map
+//# sourceMappingURL=package-PESFLDOK.js.map

package/dist/package-PESFLDOK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"package-PESFLDOK.js"}

package/dist/server.d.ts

@@ -1,20 +1,538 @@
-export { startApp, type AppOptions } from './app';
-export type { AuthConfig, AuthOption } from './app/authConfig';
-export { Module } from './app/module';
-export { RouteHandler, RouteParams, RouteResponse, RouteDefinition, HttpMethod, } from './routes/types';
+import { A as AppServer } from './index-CwdohC5n.js';
+import { M as MethodDefinition, C as ConfigSchema, S as ServerChannel, A as AuthSuccessProps, d as AuthErrorProps, U as User, W as WebsocketServerProvider, R as RoleDefinition, b as ConfigKey, e as AppConfig, f as Session, g as UserInfo, h as Role } from './types-BOFsm7A2.js';
+import { S as Store, R as RouteDefinition, C as CronJobInputParams, a as RateLimitRule, E as EmailProvider, I as InferDocumentType, b as RateLimitType, c as EmailPayload } from './types-V9eDnP35.js';
+export { H as HttpMethod, d as RouteHandler, e as RouteParams, f as RouteResponse, s as schema } from './types-V9eDnP35.js';
+import { ObjectId as ObjectId$1 } from 'mongodb';
 export { ObjectId } from 'mongodb';
-export { createQuery } from './methods';
-export { usersCollection as dbUsers } from './auth/db';
-export type { UserInfo } from './auth/types';
-export { deleteUser, disableUser } from './auth/deleteUser';
-export { schema } from './data/types';
-export { Store } from './data/store';
-export { CronJobInputParams } from './cron/types';
-export type { RateLimitRule, RateLimitType } from './rate-limit/types';
-export { consumeRateLimit } from './rate-limit/rules';
-export { getConfig } from './config/server';
-export type { CloudBackendConnectResponse } from './app/backendApi';
-export { ServerChannel } from './websocket/serverChannel';
-export { authenticate } from './auth';
-export { sendEmail } from './app/email';
-//# sourceMappingURL=server.d.ts.map
+import * as zod from 'zod';
+import 'express';
+import 'http';
+
+/** 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 */
+type Queries = Record<string, MethodDefinition<any>>;
+/** Record of mutation methods that can be called from the client */
+type Mutations = Record<string, MethodDefinition<any>>;
+/**
+ * The Module class is a core building block of a Modelence application that encapsulates related functionality.
+ * Modules can contain stores, queries, mutations, routes, cron jobs and configurations.
+ *
+ * @category Module
+ *
+ * @example
+ * ```ts
+ * const todoModule = new Module('todo', {
+ *   stores: [dbTodos],
+ *   queries: {
+ *     async getAll() {
+ *       // Fetch and return all Todo items
+ *     }
+ *   },
+ *   mutations: {
+ *     async create({ title }, { user }) {
+ *       // Create a new Todo item
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare class Module {
+    /** @internal */
+    readonly name: string;
+    /** @internal */
+    readonly stores: Stores;
+    /** @internal */
+    readonly queries: Queries;
+    /** @internal */
+    readonly mutations: Mutations;
+    /** @internal */
+    readonly routes: RouteDefinition[];
+    /** @internal */
+    readonly cronJobs: Record<string, CronJobInputParams>;
+    /** @internal */
+    readonly configSchema: ConfigSchema;
+    /** @internal */
+    readonly rateLimits: RateLimitRule[];
+    /** @internal */
+    readonly channels: ServerChannel[];
+    /**
+     * Creates a new Module instance
+     *
+     * @param name - The unique name of the module.
+     * This name is used to namespace queries, mutations,
+     * cron jobs and configuration values with a prefix (e.g. "todo.create")
+     *
+     * @param options - Module configuration options
+     */
+    constructor(name: string, { stores, queries, mutations, routes, cronJobs, configSchema, rateLimits, channels, }: {
+        stores?: Store<any, any>[];
+        queries?: Queries;
+        mutations?: Mutations;
+        routes?: RouteDefinition[];
+        cronJobs?: Record<string, CronJobInputParams>;
+        configSchema?: ConfigSchema;
+        rateLimits?: RateLimitRule[];
+        channels?: ServerChannel[];
+    });
+}
+
+type MigrationScript = {
+    version: number;
+    description: string;
+    handler: () => Promise<string | void>;
+};
+
+type EmailConfig = {
+    provider?: EmailProvider;
+    from?: string;
+    verification?: {
+        subject?: string;
+        template?: (props: {
+            name: string;
+            email: string;
+            verificationUrl: string;
+        }) => string;
+        redirectUrl?: string;
+    };
+    passwordReset?: {
+        subject?: string;
+        template?: (props: {
+            name: string;
+            email: string;
+            resetUrl: string;
+        }) => string;
+        redirectUrl?: string;
+    };
+    emailVerifiedRedirectUrl?: string;
+};
+
+/**
+ * Callback options for authentication operations
+ */
+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);
+ *     }
+ *   }
+ * });
+ * ```
+ */
+type AuthConfig = {
+    onAfterLogin?: (props: AuthSuccessProps) => void;
+    onLoginError?: (props: AuthErrorProps) => void;
+    onAfterSignup?: (props: AuthSuccessProps) => void;
+    onSignupError?: (props: AuthErrorProps) => void;
+    onAfterEmailVerification?: (props: AuthSuccessProps) => void;
+    onEmailVerificationError?: (props: AuthErrorProps) => void;
+    /** deprecated: use onAfterLogin and onLoginError */
+    login?: AuthOption;
+    /** deprecated: user onAfterSignup and onSignupError */
+    signup?: AuthOption;
+};
+
+type WebsocketConfig = {
+    provider?: WebsocketServerProvider;
+};
+
+type AppOptions = {
+    modules?: Module[];
+    server?: AppServer;
+    email?: EmailConfig;
+    auth?: AuthConfig;
+    roles?: Record<string, RoleDefinition>;
+    defaultRoles?: Record<string, string>;
+    migrations?: Array<MigrationScript>;
+    websocket?: WebsocketConfig;
+};
+declare function startApp({ modules, roles, defaultRoles, server, migrations, email, auth, websocket, }: AppOptions): Promise<void>;
+
+declare function createQuery<T extends unknown[]>(name: string, methodDef: MethodDefinition<T>): void;
+
+/** @public */
+declare abstract class BSONValue {
+    /** @public */
+    abstract get _bsontype(): string;
+    /* Excluded from this release type: [BSON_VERSION_SYMBOL] */
+    /**
+     * @public
+     * Prints a human-readable string of BSON value information
+     * If invoked manually without node.js.inspect function, this will default to a modified JSON.stringify
+     */
+    abstract inspect(depth?: number, options?: unknown, inspect?: InspectFn): string;
+    /* Excluded from this release type: toExtendedJSON */
+}
+
+declare type InspectFn = (x: unknown, options?: unknown) => string;
+
+/**
+ * A class representation of the BSON ObjectId type.
+ * @public
+ * @category BSONType
+ */
+declare class ObjectId extends BSONValue {
+    get _bsontype(): 'ObjectId';
+    /* Excluded from this release type: index */
+    static cacheHexString: boolean;
+    /* Excluded from this release type: buffer */
+    /**
+     * Create ObjectId from a number.
+     *
+     * @param inputId - A number.
+     * @deprecated Instead, use `static createFromTime()` to set a numeric value for the new ObjectId.
+     */
+    constructor(inputId: number);
+    /**
+     * Create ObjectId from a 24 character hex string.
+     *
+     * @param inputId - A 24 character hex string.
+     */
+    constructor(inputId: string);
+    /**
+     * Create ObjectId from the BSON ObjectId type.
+     *
+     * @param inputId - The BSON ObjectId type.
+     */
+    constructor(inputId: ObjectId);
+    /**
+     * Create ObjectId from the object type that has the toHexString method.
+     *
+     * @param inputId - The ObjectIdLike type.
+     */
+    constructor(inputId: ObjectIdLike);
+    /**
+     * Create ObjectId from a 12 byte binary Buffer.
+     *
+     * @param inputId - A 12 byte binary Buffer.
+     */
+    constructor(inputId: Uint8Array);
+    /** To generate a new ObjectId, use ObjectId() with no argument. */
+    constructor();
+    /**
+     * Implementation overload.
+     *
+     * @param inputId - All input types that are used in the constructor implementation.
+     */
+    constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array);
+    /**
+     * The ObjectId bytes
+     * @readonly
+     */
+    get id(): Uint8Array;
+    set id(value: Uint8Array);
+    /* Excluded from this release type: validateHexString */
+    /** Returns the ObjectId id as a 24 lowercase character hex string representation */
+    toHexString(): string;
+    /* Excluded from this release type: getInc */
+    /**
+     * Generate a 12 byte id buffer used in ObjectId's
+     *
+     * @param time - pass in a second based timestamp.
+     */
+    static generate(time?: number): Uint8Array;
+    /**
+     * Converts the id into a 24 character hex string for printing, unless encoding is provided.
+     * @param encoding - hex or base64
+     */
+    toString(encoding?: 'hex' | 'base64'): string;
+    /** Converts to its JSON the 24 character hex string representation. */
+    toJSON(): string;
+    /* Excluded from this release type: is */
+    /**
+     * Compares the equality of this ObjectId with `otherID`.
+     *
+     * @param otherId - ObjectId instance to compare against.
+     */
+    equals(otherId: string | ObjectId | ObjectIdLike | undefined | null): boolean;
+    /** Returns the generation date (accurate up to the second) that this ID was generated. */
+    getTimestamp(): Date;
+    /* Excluded from this release type: createPk */
+    /* Excluded from this release type: serializeInto */
+    /**
+     * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.
+     *
+     * @param time - an integer number representing a number of seconds.
+     */
+    static createFromTime(time: number): ObjectId;
+    /**
+     * Creates an ObjectId from a hex string representation of an ObjectId.
+     *
+     * @param hexString - create a ObjectId from a passed in 24 character hexstring.
+     */
+    static createFromHexString(hexString: string): ObjectId;
+    /** Creates an ObjectId instance from a base64 string */
+    static createFromBase64(base64: string): ObjectId;
+    /**
+     * Checks if a value can be used to create a valid bson ObjectId
+     * @param id - any JS value
+     */
+    static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean;
+    /* Excluded from this release type: toExtendedJSON */
+    /* Excluded from this release type: fromExtendedJSON */
+    /* Excluded from this release type: isCached */
+    /**
+     * Converts to a string representation of this Id.
+     *
+     * @returns return the 24 character hex string representation.
+     */
+    inspect(depth?: number, options?: unknown, inspect?: InspectFn): string;
+}
+
+/** @public */
+declare interface ObjectIdLike {
+    id: string | Uint8Array;
+    __id?: string;
+    toHexString(): string;
+}
+
+/**
+ * Database collection for storing user accounts with authentication methods and profile information.
+ *
+ * This is where **signupWithPassword** automatically creates new users.
+ *
+ * @example
+ * ```typescript
+ * // Find user by email
+ * const user = await dbUsers.findOne(
+ *   { 'emails.address': 'john@example.com' }
+ * );
+ * ```
+ *
+ */
+declare const usersCollection: Store<{
+    handle: zod.ZodString;
+    emails: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        address: zod.ZodString;
+        verified: zod.ZodBoolean;
+    }, "strip", zod.ZodTypeAny, {
+        address: string;
+        verified: boolean;
+    }, {
+        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<{
+            hash: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            hash: string;
+        }, {
+            hash: string;
+        }>>;
+        google: zod.ZodOptional<zod.ZodObject<{
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>>;
+        github: zod.ZodOptional<zod.ZodObject<{
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>>;
+    }, "strip", zod.ZodTypeAny, {
+        password?: {
+            hash: string;
+        } | undefined;
+        google?: {
+            id: string;
+        } | undefined;
+        github?: {
+            id: string;
+        } | undefined;
+    }, {
+        password?: {
+            hash: string;
+        } | undefined;
+        google?: {
+            id: string;
+        } | undefined;
+        github?: {
+            id: string;
+        } | undefined;
+    }>;
+}, Record<string, (this: Pick<InferDocumentType<{
+    handle: zod.ZodString;
+    emails: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        address: zod.ZodString;
+        verified: zod.ZodBoolean;
+    }, "strip", zod.ZodTypeAny, {
+        address: string;
+        verified: boolean;
+    }, {
+        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<{
+            hash: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            hash: string;
+        }, {
+            hash: string;
+        }>>;
+        google: zod.ZodOptional<zod.ZodObject<{
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>>;
+        github: zod.ZodOptional<zod.ZodObject<{
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>>;
+    }, "strip", zod.ZodTypeAny, {
+        password?: {
+            hash: string;
+        } | undefined;
+        google?: {
+            id: string;
+        } | undefined;
+        github?: {
+            id: string;
+        } | undefined;
+    }, {
+        password?: {
+            hash: string;
+        } | undefined;
+        google?: {
+            id: string;
+        } | undefined;
+        github?: {
+            id: string;
+        } | undefined;
+    }>;
+}>, "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.
+ *
+ * @category Rate Limits
+ *
+ * @example
+ * ```ts
+ * await consumeRateLimit({ bucket: 'api', type: 'ip', value: '127.0.0.1' });
+ * ```
+ * @param options.bucket - The bucket for the rate limit.
+ * @param options.type - The type of the rate limit.
+ * @param options.value - The value for the rate limit.
+ */
+declare function consumeRateLimit(options: {
+    bucket: string;
+    type: RateLimitType;
+    value: string;
+}): Promise<void>;
+
+/**
+ * @sidebarTitle getConfig (server)
+ *
+ * @param key - The configuration key to retrieve
+ * @returns The configuration value (string, number, or boolean)
+ *
+ * @example
+ * ```ts
+ * import { getConfig } from 'modelence/server';
+ *
+ * // Get the site URL
+ * const siteUrl = getConfig('_system.site.url');
+ * ```
+ *
+ * Set via environment variable:
+ * ```bash
+ * MODELENCE_SITE_URL=https://myapp.com
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { getConfig } from 'modelence/server';
+ *
+ * // Get the current environment (e.g., 'development', 'staging', 'production')
+ * const env = getConfig('_system.env');
+ *
+ * if (env === 'production') {
+ *   // Enable production features
+ * }
+ * ```
+ *
+ * Set via environment variable:
+ * ```bash
+ * MODELENCE_SITE_ENV=production
+ * ```
+ */
+declare function getConfig(key: ConfigKey): string | number | boolean;
+
+type CloudBackendConnectOkResponse = {
+    status: 'ok';
+    configs: AppConfig[];
+    environmentId: string;
+    appAlias: string;
+    environmentAlias: string;
+    telemetry: {
+        isEnabled: boolean;
+        serviceName: string;
+    };
+};
+type CloudBackendConnectErrorResponse = {
+    status: 'error';
+    error: string;
+};
+type CloudBackendConnectResponse = CloudBackendConnectOkResponse | CloudBackendConnectErrorResponse;
+
+declare function authenticate(authToken: string | null): Promise<{
+    session: Session;
+    user: UserInfo | null;
+    roles: Role[];
+}>;
+
+declare function sendEmail(payload: EmailPayload): Promise<void> | undefined;
+
+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 };