@c15t/backend 1.8.0 → 2.0.0-rc.0

package/dist/pkgs/results/results/result-helpers.d.ts

@@ -1,214 +0,0 @@
-import { DoubleTieError } from '../core/error-class';
-import type { ErrorMessageType, ErrorTransformer, SDKResult, SDKResultAsync } from '../types';
-/**
- * Creates a successful result containing the provided value.
- *
- * @template TValue - The type of the success value
- * @param value - The value to wrap in a success result
- * @returns A Result containing the value
- *
- * @example
- * ```typescript
- * const result = ok('John Doe');
- * ```
- */
-export { ok } from 'neverthrow';
-/**
- * Creates a failure result containing a DoubleTieError with the provided message and options.
- *
- * @template TValue - The type of the expected success value (had the operation succeeded)
- * @param message - Human-readable error message
- * @param options - Error options including code, status, and other metadata
- * @returns A Result containing the error
- *
- * @remarks
- * This is the counterpart to the `ok` function and should be used when an operation
- * fails and you want to create a Result representing the failure.
- *
- * @see ok for creating successful results
- * @see DoubleTieError for more details on the error options
- *
- * @example
- * ```typescript
- * // Create a failure result for a not found error
- * const result = fail<User>('User not found', {
- *   code: ERROR_CODES.NOT_FOUND,
- *   status: 404,
- *   meta: { userId: '123' }
- * });
- *
- * // Use with match for safe handling
- * result.match(
- *   (user) => console.log(user), // Will not be called
- *   (error) => console.error(`${error.code}: ${error.message}`) // Will be called
- * );
- * ```
- */
-export declare function fail<TValue>(message: string, options: ConstructorParameters<typeof DoubleTieError>[1]): SDKResult<TValue>;
-/**
- * Creates an asynchronous failure result containing a DoubleTieError with the provided message and options.
- *
- * @template TValue - The type of the expected success value (had the operation succeeded)
- * @param message - Human-readable error message
- * @param options - Error options including code, status, and other metadata
- * @returns A ResultAsync containing the error
- *
- * @remarks
- * This is the asynchronous counterpart to the `fail` function and should be used when an
- * operation fails and you want to create a ResultAsync representing the failure.
- *
- * @see okAsync for creating successful async results
- * @see fail for the synchronous version
- *
- * @example
- * ```typescript
- * // Create an async failure result for an authentication error
- * const result = failAsync<Session>('Authentication failed', {
- *   code: ERROR_CODES.UNAUTHORIZED,
- *   status: 401,
- *   meta: { attempt: 3 }
- * });
- *
- * // Chain with other async operations
- * const profile = await result
- *   .orElse(err => {
- *     // Handle the error or return another result
- *     console.error(`Auth failed: ${err.message}`);
- *     return okAsync(createGuestSession());
- *   })
- *   .andThen(session => getProfile(session.userId));
- * ```
- */
-export declare function failAsync<TValue>(message: string, options: ConstructorParameters<typeof DoubleTieError>[1]): SDKResultAsync<TValue>;
-/**
- * Safely executes a function that might throw and converts the result into a Result type.
- * If the function throws, the error is transformed into a DoubleTieError.
- *
- * @template TValue - The type of the success value returned by the function
- * @param fn - The function to execute
- * @param errorCode - The error code to use if the function throws (defaults to UNKNOWN_ERROR)
- * @param errorMapper - Optional function to customize how errors are transformed into DoubleTieErrors
- * @returns A Result containing either the function's return value or a DoubleTieError
- *
- * @remarks
- * This function is useful for wrapping existing code that uses try/catch
- * to make it work with the Result pattern. It allows safe execution of
- * operations that might throw exceptions.
- *
- * @see tryCatchAsync for the asynchronous version
- *
- * @example
- * ```typescript
- * // Wrap a function that might throw
- * const parseConfig = (configStr: string) => {
- *   return tryCatch(
- *     () => JSON.parse(configStr),
- *     ERROR_CODES.INVALID_CONFIG,
- *     (err) => new DoubleTieError(`Failed to parse config: ${err.message}`, {
- *       code: ERROR_CODES.INVALID_CONFIG,
- *       status: 400,
- *       cause: err,
- *       meta: { configStr }
- *     })
- *   );
- * };
- *
- * // Use the wrapped function
- * const configResult = parseConfig(rawConfig);
- * configResult.match(
- *   (config) => initializeApp(config),
- *   (error) => logError('Config error', error)
- * );
- * ```
- */
-export declare function tryCatch<TValue>(fn: () => TValue, errorCode?: ErrorMessageType, errorMapper?: ErrorTransformer): SDKResult<TValue>;
-/**
- * Safely executes an asynchronous function that might throw and converts the result into a ResultAsync type.
- * If the function throws, the error is transformed into a DoubleTieError.
- *
- * @template TValue - The type of the success value returned by the function
- * @param fn - The asynchronous function to execute
- * @param errorCode - The error code to use if the function throws (defaults to UNKNOWN_ERROR)
- * @param errorMapper - Optional function to customize how errors are transformed into DoubleTieErrors
- * @returns A ResultAsync containing either the function's return value or a DoubleTieError
- *
- * @remarks
- * This function is useful for wrapping existing asynchronous code that uses try/catch
- * to make it work with the Result pattern. It allows safe execution of
- * operations that might throw exceptions.
- *
- * @see tryCatch for the synchronous version
- * @see promiseToResult for wrapping an existing Promise
- *
- * @example
- * ```typescript
- * // Wrap an async function that might throw
- * const fetchUserData = (userId: string) => {
- *   return tryCatchAsync(
- *     async () => {
- *       const response = await fetch(`/api/users/${userId}`);
- *       if (!response.ok) {
- *         throw new Error(`HTTP error ${response.status}`);
- *       }
- *       return response.json();
- *     },
- *     ERROR_CODES.API_ERROR,
- *     (err) => new DoubleTieError(`Failed to fetch user data: ${err.message}`, {
- *       code: ERROR_CODES.API_ERROR,
- *       status: 500,
- *       cause: err,
- *       meta: { userId }
- *     })
- *   );
- * };
- *
- * // Use the wrapped function
- * const userData = await fetchUserData('123')
- *   .match(
- *     (data) => processUserData(data),
- *     (error) => handleApiError(error)
- *   );
- * ```
- */
-export declare function tryCatchAsync<TValue>(fn: () => Promise<TValue>, errorCode?: ErrorMessageType, errorMapper?: ErrorTransformer): SDKResultAsync<TValue>;
-/**
- * Converts a Promise into a ResultAsync. If the Promise resolves, the result will be a success.
- * If the Promise rejects, the error will be transformed into a DoubleTieError.
- *
- * @template TValue - The type of the success value returned by the Promise
- * @param promise - The Promise to convert
- * @param errorCode - The error code to use if the Promise rejects (defaults to UNKNOWN_ERROR)
- * @returns A ResultAsync containing either the Promise's resolved value or a DoubleTieError
- *
- * @remarks
- * This function is useful for wrapping existing Promise-based APIs to make them
- * work with the Result pattern. Unlike tryCatchAsync, this function takes an
- * already-created Promise rather than a function that returns a Promise.
- *
- * @see tryCatchAsync for wrapping async functions
- *
- * @example
- * ```typescript
- * // Wrap an existing Promise
- * const fetchData = (url: string) => {
- *   const promise = fetch(url)
- *     .then(response => {
- *       if (!response.ok) {
- *         throw new Error(`HTTP error ${response.status}`);
- *       }
- *       return response.json();
- *     });
- *
- *   return promiseToResult(promise, ERROR_CODES.API_ERROR);
- * };
- *
- * // Use the wrapped function
- * const result = await fetchData('https://api.example.com/data');
- * result.match(
- *   (data) => console.log('Data:', data),
- *   (error) => console.error(`Error ${error.code}: ${error.message}`)
- * );
- * ```
- */
-export declare function promiseToResult<TValue>(promise: Promise<TValue>, errorCode?: ErrorMessageType): SDKResultAsync<TValue>;
-//# sourceMappingURL=result-helpers.d.ts.map

package/dist/pkgs/results/results/result-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-helpers.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/results/result-helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,KAAK,EACX,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,cAAc,EACd,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAC1B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,qBAAqB,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,GACtD,SAAS,CAAC,MAAM,CAAC,CAWnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,qBAAqB,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,GACtD,cAAc,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAC9B,EAAE,EAAE,MAAM,MAAM,EAChB,SAAS,GAAE,gBAA4C,EACvD,WAAW,CAAC,EAAE,gBAAgB,GAC5B,SAAS,CAAC,MAAM,CAAC,CAuCnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,aAAa,CAAC,MAAM,EACnC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EACzB,SAAS,GAAE,gBAA4C,EACvD,WAAW,CAAC,EAAE,gBAAgB,GAC5B,cAAc,CAAC,MAAM,CAAC,CAkDxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,eAAe,CAAC,MAAM,EACrC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,EACxB,SAAS,GAAE,gBAA4C,GACrD,cAAc,CAAC,MAAM,CAAC,CA4BxB"}

package/dist/pkgs/results/types.d.ts

@@ -1,200 +0,0 @@
-import type { ORPCError } from '@orpc/server';
-import type { Result, ResultAsync } from 'neverthrow';
-/**
- * Represents a category of errors for better organization and filtering.
- *
- * @remarks
- * Error categories allow grouping related errors together and can be used
- * for filtering, routing, or specialized handling of different error types.
- *
- * @see ERROR_CATEGORIES for predefined categories
- *
- * @example
- * ```typescript
- * // Using a predefined category
- * const error = new DoubleTieError('Not authorized', {
- *   code: ERROR_CODES.UNAUTHORIZED,
- *   category: ERROR_CATEGORIES.AUTH
- * });
- * ```
- */
-export type ErrorCategory = string;
-/**
- * Represents an error code message used for identifying error types.
- *
- * @remarks
- * Error codes should be unique identifiers that help track and identify
- * specific error conditions throughout the application.
- *
- * @see ERROR_CODES for predefined error codes
- *
- * @example
- * ```typescript
- * // Using a predefined error code
- * const error = new DoubleTieError('Resource not found', {
- *   code: ERROR_CODES.NOT_FOUND
- * });
- * ```
- */
-export type ErrorMessageType = string;
-/**
- * Forward declaration of the DoubleTieError class to avoid circular imports.
- * Actual implementation is in error-class.ts
- *
- * @remarks
- * This interface defines the public API of the DoubleTieError class.
- * It extends the ORPCError class with additional properties and methods
- * specific to the DoubleTie error handling system.
- *
- * @see DoubleTieErrorOptions for the options used to construct a DoubleTieError
- */
-export interface DoubleTieError extends ORPCError<string, Record<string, unknown>> {
-    /**
-     * Error code identifying the error type
-     */
-    readonly code: ErrorMessageType;
-    /**
-     * Category for grouping related errors
-     */
-    readonly category: ErrorCategory;
-    /**
-     * Additional metadata about the error
-     */
-    readonly meta: Record<string, unknown>;
-    /**
-     * HTTP status code for the error
-     */
-    readonly statusCode: number;
-    /**
-     * Creates a new error instance with additional metadata
-     */
-    withMeta(additionalMeta: Record<string, unknown>): DoubleTieError;
-}
-/**
- * Options for constructing a DoubleTieError
- *
- * @remarks
- * This interface defines all the configuration options available
- * when creating a new DoubleTieError instance.
- *
- * @example
- * ```typescript
- * const options: DoubleTieErrorOptions = {
- *   code: ERROR_CODES.VALIDATION_ERROR,
- *   status: 400,
- *   category: ERROR_CATEGORIES.VALIDATION,
- *   meta: { field: 'email', value: 'invalid' }
- * };
- *
- * const error = new DoubleTieError('Invalid email format', options);
- * ```
- */
-export interface DoubleTieErrorOptions {
-    /**
-     * Error code from ERROR_CODES or custom error codes.
-     * Used to uniquely identify the error type.
-     */
-    code: ErrorMessageType;
-    /**
-     * HTTP status code if applicable.
-     * Defaults to 500 (Internal Server Error) if not specified.
-     */
-    status?: number;
-    /**
-     * Category to classify the error.
-     * Defaults to 'unexpected' if not specified.
-     */
-    category?: ErrorCategory;
-    /**
-     * Original error that caused this error.
-     * Useful for wrapping and preserving the original error stack trace.
-     */
-    cause?: Error;
-    /**
-     * Additional metadata about the error.
-     * Can contain any contextual information that might help debugging.
-     */
-    meta?: Record<string, unknown>;
-}
-/**
- * Represents a synchronous result that may contain a value of type TValue or a DoubleTieError.
- * Based on the Result type from the neverthrow library.
- *
- * @template TValue - The type of the success value
- *
- * @remarks
- * SDKResult is a wrapper around the neverthrow Result type specialized to use DoubleTieError
- * as the error type. It provides methods to safely handle both success and error cases.
- *
- * @example
- * ```typescript
- * // Creating and using a result
- * const result: SDKResult<User> = getUserById(123);
- *
- * // Safely handling the result
- * result.match(
- *   (user) => console.log(`Found user: ${user.name}`),
- *   (error) => console.error(`Error: ${error.message}`)
- * );
- *
- * // Using the result with other functions
- * const nameResult = result.map(user => user.name);
- * ```
- */
-export type SDKResult<TValue> = Result<TValue, DoubleTieError>;
-/**
- * Represents an asynchronous result that may contain a value of type TValue or a DoubleTieError.
- * Based on the ResultAsync type from the neverthrow library.
- *
- * @template TValue - The type of the success value
- *
- * @remarks
- * SDKResultAsync is a wrapper around the neverthrow ResultAsync type specialized to use DoubleTieError
- * as the error type. It provides methods to safely handle both success and error cases in asynchronous operations.
- *
- * @example
- * ```typescript
- * // Creating and using an async result
- * const resultAsync: SDKResultAsync<User> = getUserByIdAsync(123);
- *
- * // Safely handling the result
- * await resultAsync.match(
- *   (user) => console.log(`Found user: ${user.name}`),
- *   (error) => console.error(`Error: ${error.message}`)
- * );
- *
- * // Chaining async operations
- * const profileResult = await resultAsync
- *   .andThen(user => getProfileByUserId(user.id));
- * ```
- */
-export type SDKResultAsync<TValue> = ResultAsync<TValue, DoubleTieError>;
-/**
- * Callback function type for mapping errors to DoubleTieErrors.
- * Used in utility functions like tryCatch and tryCatchAsync to transform
- * arbitrary errors into DoubleTieErrors.
- *
- * @template TError - The type of the original error
- *
- * @example
- * ```typescript
- * const errorTransformer: ErrorTransformer = (error) => {
- *   if (error instanceof NetworkError) {
- *     return new DoubleTieError('Network connection failed', {
- *       code: ERROR_CODES.NETWORK_ERROR,
- *       status: 503,
- *       cause: error
- *     });
- *   }
- *   return new DoubleTieError('Unknown error occurred', {
- *     code: ERROR_CODES.UNKNOWN_ERROR,
- *     cause: error
- *   });
- * };
- *
- * // Using the transformer with tryCatch
- * const result = tryCatch(() => riskyOperation(), ERROR_CODES.OPERATION_FAILED, errorTransformer);
- * ```
- */
-export type ErrorTransformer<TError extends Error = Error> = (error: TError) => DoubleTieError;
-//# sourceMappingURL=types.d.ts.map

package/dist/pkgs/results/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/pkgs/results/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAChB,SAAQ,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEhC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,qBAAqB;IACrC;;;OAGG;IACH,IAAI,EAAE,gBAAgB,CAAC;IAEvB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,SAAS,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,IAAI,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,KAAK,GAAG,KAAK,IAAI,CAC5D,KAAK,EAAE,MAAM,KACT,cAAc,CAAC"}

package/dist/pkgs/types/context.d.ts

@@ -1,160 +0,0 @@
-import type { createLogger } from '@c15t/logger';
-import type { DatabaseHook, EntityName } from '../data-model';
-import type { Adapter } from '../db-adapters/types';
-import type { createRegistry } from '../../schema/create-registry';
-import type { getConsentTables } from '../../schema/definition';
-import type { DoubleTieOptions } from './options';
-/**
- * Extended endpoint context for hooks
- *
- * This type extends the standard endpoint context with additional properties
- * specific to DoubleTie hooks, allowing hooks to access the complete DoubleTie context.
- */
-export type HookEndpointContext = {
-    /**
-     * The request object
-     */
-    request: Request;
-    /**
-     * The DoubleTie context with possible hook-specific extensions
-     */
-    context: DoubleTieContext & {
-        /**
-         * Value returned by the endpoint handler, available in 'after' hooks
-         */
-        returned?: unknown;
-        /**
-         * Response headers, available in 'after' hooks
-         */
-        responseHeaders?: Headers;
-    };
-};
-/**
- * Generic endpoint context type
- *
- * A simplified context type for endpoint handlers that don't need
- * access to input-specific context properties.
- */
-export type GenericEndpointContext = {
-    /**
-     * The request object
-     */
-    request: Request;
-    /**
-     * The DoubleTie application context
-     */
-    context: DoubleTieContext;
-};
-/**
- * Base context interface
- *
- * Defines the minimal required properties for a DoubleTie context.
- */
-export interface BaseContext {
-    /**
-     * Configuration options for the DoubleTie system
-     */
-    options: DoubleTieOptions;
-    /**
-     * Logger instance for recording events and errors
-     */
-    logger: ReturnType<typeof createLogger>;
-}
-/**
- * Registry context interface
- *
- * Extends the base context with registry-specific properties
- * for database access and entity management.
- */
-export interface RegistryContext extends BaseContext {
-    /**
-     * Database adapter instance
-     */
-    adapter: Adapter;
-    /**
-     * Database lifecycle hooks
-     */
-    hooks: DatabaseHook[];
-    /**
-     * Function to generate unique IDs for entities
-     *
-     * @param options - Options for ID generation including entity type and length
-     * @returns A unique ID string
-     */
-    generateId: (options: {
-        model: EntityName;
-        size?: number;
-    }) => string;
-}
-/**
- * Base DoubleTie context interface
- *
- * Defines the core properties available in all DoubleTie application contexts.
- * This forms the foundation for the complete context used throughout the system.
- */
-export interface BaseDoubleTieContext {
-    /**
-     * Application name displayed in application dialogs
-     */
-    appName: string;
-    /**
-     * Configuration options for the DoubleTie system
-     */
-    options: DoubleTieOptions;
-    /**
-     * List of origins that are trusted for CORS and CSRF protection
-     */
-    trustedOrigins: string[];
-    /**
-     * Base URL for API requests
-     */
-    baseURL: string;
-    /**
-     * Logger instance for recording events and errors
-     */
-    logger: ReturnType<typeof createLogger>;
-    /**
-     * Function to generate unique IDs for entities
-     *
-     * @param options - Options for ID generation including entity type and length
-     * @returns A unique ID string
-     */
-    generateId: (options: {
-        model: EntityName;
-        size?: number;
-    }) => string;
-    /**
-     * Database adapter instance
-     */
-    adapter: Adapter;
-    /**
-     * Entity registry for database operations
-     */
-    registry: ReturnType<typeof createRegistry>;
-    /**
-     * Database tables for the system
-     */
-    tables: ReturnType<typeof getConsentTables>;
-    /**
-     * IP address of the client
-     */
-    ipAddress?: string | null;
-    /**
-     * User agent of the client
-     */
-    userAgent?: string | null;
-    /**
-     * Headers of the request
-     */
-    headers?: Headers;
-}
-/**
- * Complete DoubleTie context type
- *
- * This type combines the base context with plugin-specific context extensions.
- * It's the primary context type used throughout the system.
- *
- * @typeParam TPluginContext - Record of plugin-specific context properties
- */
-export type DoubleTieContext<TPluginContext extends Record<string, unknown> = Record<string, unknown>> = BaseDoubleTieContext & TPluginContext;
-//# sourceMappingURL=context.d.ts.map

package/dist/pkgs/types/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/pkgs/types/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,gBAAgB,GAAG;QAC3B;;WAEG;QACH,QAAQ,CAAC,EAAE,OAAO,CAAC;QAEnB;;WAEG;QACH,eAAe,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACpC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC3B;;OAEG;IACH,OAAO,EAAE,gBAAgB,CAAC;IAE1B;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAgB,SAAQ,WAAW;IACnD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,KAAK,EAAE,YAAY,EAAE,CAAC;IAEtB;;;;;OAKG;IACH,UAAU,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;CACtE;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,OAAO,EAAE,gBAAgB,CAAC;IAE1B;;OAEG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IAExC;;;;;OAKG;IACH,UAAU,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;IAEtE;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IAE5C;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;IAE5C;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAC3B,cAAc,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACrE,oBAAoB,GAAG,cAAc,CAAC"}

package/dist/pkgs/types/endpoints.d.ts

@@ -1,30 +0,0 @@
-export interface EndpointOptions {
-    /**
-     * Whether authentication is required for this endpoint
-     */
-    auth?: boolean;
-    /**
-     * Custom middleware to run before the endpoint
-     */
-    middleware?: EndpointMiddleware[];
-}
-export type EndpointMiddleware = (request: Request) => Promise<void>;
-export type EndpointHandler = (request: Request) => Promise<unknown>;
-/**
- * Native endpoint interface
- */
-export interface Endpoint {
-    /**
-     * The endpoint handler function
-     */
-    handler: EndpointHandler;
-    /**
-     * Configuration options for the endpoint
-     */
-    options?: EndpointOptions;
-    /**
-     * The path for this endpoint
-     */
-    path: string;
-}
-//# sourceMappingURL=endpoints.d.ts.map

package/dist/pkgs/types/endpoints.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"endpoints.d.ts","sourceRoot":"","sources":["../../../src/pkgs/types/endpoints.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC/B;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,kBAAkB,EAAE,CAAC;CAClC;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB;;OAEG;IACH,OAAO,EAAE,eAAe,CAAC;IAEzB;;OAEG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAE1B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACb"}

package/dist/pkgs/types/helper.d.ts

@@ -1,55 +0,0 @@
-/**
- * Represents a string literal type
- *
- * This type ensures that only string literals are accepted, not general string types.
- * It's useful for ensuring type safety with specific string values.
- *
- * @example
- * ```ts
- * // Function that only accepts literal strings, not string variables
- * function doSomething(value: LiteralString) {
- *   // Implementation
- * }
- *
- * // Valid usage:
- * doSomething('specific-value');
- *
- * // Invalid usage:
- * const dynamicString = getStringFromSomewhere();
- * doSomething(dynamicString); // Type error
- * ```
- */
-export type LiteralString = '' | (string & Record<never, never>);
-/**
- * Makes all properties in an object optional recursively
- *
- * This is like TypeScript's built-in Partial<T>, but it goes deeper into
- * nested objects to make their properties optional too.
- *
- * @typeParam T - The type to make deeply partial
- *
- * @example
- * ```ts
- * interface User {
- *   id: string;
- *   name: string;
- *   settings: {
- *     theme: string;
- *     notifications: boolean;
- *   }
- * }
- *
- * // All properties are optional, including nested ones
- * const partialUser: DeepPartial<User> = {
- *   name: 'Alice',
- *   settings: {
- *     theme: 'dark'
- *     // notifications is optional
- *   }
- * };
- * ```
- */
-export type DeepPartial<T> = T extends (...args: unknown[]) => unknown ? T : T extends object ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-//# sourceMappingURL=helper.d.ts.map

package/dist/pkgs/types/helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../../src/pkgs/types/helper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,aAAa,GAAG,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,GACnE,CAAC,GACD,CAAC,SAAS,MAAM,GACf;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACtC,CAAC,CAAC"}