modelence 0.9.0-dev.0 → 0.9.0

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-SXHKNPNY.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
@@ -66,10 +162,10 @@ type StrictRootFilterOperators<TSchema> = {
  * await dbUsers.findOne({ id: '123' });
  * ```
  */
-export type TypedFilter<T> = {
+type TypedFilter<T> = {
     [K in keyof WithId<T>]?: WithId<T>[K] | FilterOperators<WithId<T>[K]>;
 } & StrictRootFilterOperators<T> & {
-    [K: DottedString]: any;
+    [K: `${string}.${string}`]: any;
 };
 /**
  * Helper type to preserve method types when extending a store.
@@ -103,7 +199,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 +234,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 +427,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 +519,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-SXHKNPNY.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.0",
   "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"}

package/dist/app/backendApi.d.ts

@@ -1,29 +0,0 @@
-import { ConfigSchema } from '../config/types';
-import { CronJobMetadata } from '../cron/types';
-import { Store } from '../data/store';
-import { AppConfig } from '../config/types';
-type CloudBackendConnectOkResponse = {
-    status: 'ok';
-    configs: AppConfig[];
-    environmentId: string;
-    appAlias: string;
-    environmentAlias: string;
-    telemetry: {
-        isEnabled: boolean;
-        serviceName: string;
-    };
-};
-type CloudBackendConnectErrorResponse = {
-    status: 'error';
-    error: string;
-};
-export type CloudBackendConnectResponse = CloudBackendConnectOkResponse | CloudBackendConnectErrorResponse;
-export declare function connectCloudBackend({ configSchema, cronJobsMetadata, stores, }: {
-    configSchema?: ConfigSchema;
-    cronJobsMetadata?: CronJobMetadata[];
-    stores: Store<any, any>[];
-}): Promise<CloudBackendConnectOkResponse>;
-export declare function fetchConfigs(): Promise<any>;
-export declare function syncStatus(): Promise<any>;
-export {};
-//# sourceMappingURL=backendApi.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backendApi.d.ts","sourceRoot":"","sources":["../../src/app/backendApi.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,KAAK,6BAA6B,GAAG;IACnC,MAAM,EAAE,IAAI,CAAC;IACb,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE;QACT,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC;AAEF,KAAK,gCAAgC,GAAG;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACnC,6BAA6B,GAC7B,gCAAgC,CAAC;AAErC,wBAAsB,mBAAmB,CAAC,EACxC,YAAY,EACZ,gBAAgB,EAChB,MAAM,GACP,EAAE;IACD,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IAErC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;CAC3B,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAmCzC;AAED,wBAAsB,YAAY,iBAGjC;AAED,wBAAsB,UAAU,iBAK/B"}