@modelence/react-query 1.0.1 → 1.2.0

package/.yalc/modelence/dist/index.d.ts

@@ -0,0 +1,31 @@
+export { C as ConfigSchema, a as WebsocketClientProvider, W as WebsocketServerProvider } from './types-Ds1ESQSs.js';
+export { M as ModelenceConfig } from './index-CwdohC5n.js';
+import 'http';
+import 'mongodb';
+import 'express';
+
+declare const time: {
+    seconds: (x: number) => number;
+    minutes: (x: number) => number;
+    hours: (x: number) => number;
+    days: (x: number) => number;
+    weeks: (x: number) => number;
+};
+
+declare abstract class ModelenceError extends Error {
+    abstract status: number;
+}
+declare class AuthError extends ModelenceError {
+    status: number;
+    constructor(message: string);
+}
+declare class ValidationError extends ModelenceError {
+    status: number;
+    constructor(message: string);
+}
+declare class RateLimitError extends ModelenceError {
+    status: number;
+    constructor(message: string);
+}
+
+export { AuthError, RateLimitError, ValidationError, time };

package/.yalc/modelence/dist/index.js

@@ -0,0 +1,2 @@
+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/.yalc/modelence/dist/index.js.map

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

package/.yalc/modelence/dist/mongo.d.ts

@@ -0,0 +1,5 @@
+export { ClientSession, ObjectId } from 'mongodb';
+
+declare const _default: {};
+
+export { _default as default };

package/.yalc/modelence/dist/mongo.js

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

package/.yalc/modelence/dist/mongo.js.map

@@ -0,0 +1 @@
+{"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/.yalc/modelence/dist/package-3YQBVIVQ.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-3YAV3UUU.js';//# sourceMappingURL=package-3YQBVIVQ.js.map
+//# sourceMappingURL=package-3YQBVIVQ.js.map

package/.yalc/modelence/dist/package-3YQBVIVQ.js.map

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

package/.yalc/modelence/dist/server.d.ts

@@ -0,0 +1,569 @@
+import { A as AppServer } from './index-CwdohC5n.js';
+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-WgRbQ-tj.js';
+export { H as HttpMethod, e as RouteHandler, f as RouteParams, g as RouteResponse, s as schema } from './types-WgRbQ-tj.js';
+import { ObjectId as ObjectId$1 } from 'mongodb';
+export { ObjectId } from 'mongodb';
+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: {
+        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;
+};
+
+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>;
+
+/**
+ * Publish function provided to live query handlers.
+ * Call this to send data to the subscribed client.
+ */
+type LiveQueryPublish<T = unknown> = (data: T) => void;
+/**
+ * Cleanup function returned by live query handlers.
+ * Called when the client unsubscribes.
+ */
+type LiveQueryCleanup = () => void;
+/**
+ * Context provided to live query handlers.
+ */
+interface LiveQueryContext {
+    publish: LiveQueryPublish;
+}
+
+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, type LiveQueryCleanup, type LiveQueryContext, type LiveQueryPublish, Module, RateLimitRule, RateLimitType, RouteDefinition, ServerChannel, Store, UserInfo, authenticate, consumeRateLimit, createQuery, usersCollection as dbUsers, deleteUser, disableUser, getConfig, sendEmail, startApp };