@mayhem93/nexxus-core-lib 0.0.1 → 0.0.2

package/dist-types/models/AppModel.d.ts

@@ -1,9 +1,35 @@
+import { NexxusApplicationSchema } from "./Application";
 import { NexxusBaseModel, INexxusBaseModel } from "./BaseModel";
-export type NexxusAppModelType = INexxusBaseModel & {
+export interface INexxusAppModel extends INexxusBaseModel {
     appId: string;
     userId?: string;
-    [key: string]: any;
-};
-export declare class NexxusAppModel extends NexxusBaseModel<NexxusAppModelType> {
-    constructor(props: NexxusAppModelType);
+    /**
+     * Monotonically-increasing per-document version counter, assigned by the
+     * database adapter on every write. Used for client-side gap detection and
+     * dedup when applying real-time update events. App models flow through the
+     * async Writer → Transport Manager → client pipeline; built-in models
+     * (Application, User) do not and therefore do not carry a version.
+     * Never set by user input — the validator rejects user-supplied values.
+     */
+    version?: number;
+    [key: string]: unknown;
+}
+export declare class NexxusAppModel extends NexxusBaseModel<INexxusAppModel> {
+    /**
+     * Construct an AppModel from user-supplied or pre-validated data.
+     *
+     * Pass the application's schema as the second argument to validate + normalize
+     * the input (e.g. date strings → integer timestamps). Pass `null` to skip
+     * validation — only do that when the data is already trusted (e.g. coming
+     * back from storage). The `fromStorage` static factory below is the preferred
+     * way to express that intent.
+     */
+    constructor(props: INexxusAppModel, appSchema: NexxusApplicationSchema | null);
+    /**
+     * Hydrate an AppModel from already-validated storage. Use when reading back
+     * from the database — the data was validated when it was written, so we don't
+     * re-validate (saves work and avoids false-positives on legacy/edge-case docs
+     * that pre-date a later schema change).
+     */
+    static fromStorage(props: INexxusAppModel): NexxusAppModel;
 }

package/dist-types/models/Application.d.ts

@@ -1,5 +1,8 @@
-import { NexxusBaseModel, INexxusBaseModel } from "./BaseModel";
+import { INexxusBaseModel } from "./BaseModel";
+import { NexxusBuiltinModel } from "./BuiltinModel";
 import { NexxusModelDef } from "../common/ModelTypes";
+import { InferModel } from "../common/InferModel";
+import { NEXXUS_BUILTIN_MODEL_SCHEMAS } from "../common/BuiltinSchemas";
 import { NexxusUserDetailSchema } from "./User";
 export interface NexxusApplicationSchema {
     [modelName: string]: NexxusModelDef;
@@ -7,23 +10,48 @@ export interface NexxusApplicationSchema {
 export interface NexxusUserTypeConfig {
     private?: boolean;
 }
-export type NexxusApplicationModelType = INexxusBaseModel<'application'> & {
-    name: string;
-    description?: string;
+/**
+ * Per-application auth configuration. Lives on the Application document so
+ * that each tenant carries its own JWT secret and per-strategy settings.
+ *
+ * `strategies` is a map keyed by strategy name (must be a subset of the
+ * deployment's `api.auth.availableStrategies`). Each value's shape is
+ * whatever the strategy's own JSON Schema defines — validated by the
+ * corresponding `NexxusAuthStrategy` subclass at instantiation time.
+ */
+export interface NexxusApplicationAuthConfig {
+    jwtSecret: string;
+    jwtExpiresIn?: string;
+    strategies: Record<string, unknown>;
+}
+export type INexxusApplication = INexxusBaseModel<'application'> & InferModel<typeof NEXXUS_BUILTIN_MODEL_SCHEMAS.application> & {
     schema: NexxusApplicationSchema;
-    authEnabled: boolean;
-    allowMultipleLogin: boolean | null;
     userTypes?: {
         [userType: string]: NexxusUserTypeConfig;
     };
     userDetailSchema?: {
         [userType: string]: NexxusUserDetailSchema;
     };
+    auth?: NexxusApplicationAuthConfig;
+    defaultLimit?: number;
+    maxLimit?: number;
 };
-export declare class NexxusApplication extends NexxusBaseModel<NexxusApplicationModelType> {
-    constructor(data: NexxusApplicationModelType);
+export declare class NexxusApplication extends NexxusBuiltinModel<INexxusApplication> {
+    constructor(data: INexxusApplication);
     getSchema(): NexxusApplicationSchema;
     getUserDetailSchema(userType?: string): NexxusUserDetailSchema | null;
+    hasAuthEnabled(): boolean;
+    /**
+     * Runtime field schema for one of the developer-declared models in this
+     * application's `schema` field. Built-in models (user, application) have
+     * their own static `getModelSchema` and are not resolved here.
+     */
+    getAppModelSchema(modelType: string): NexxusModelDef;
+    /**
+     * Runtime field schema for Application records. Static because the schema
+     * is global — not per-app.
+     */
+    static getModelSchema(): NexxusModelDef;
     getAppModelFieldType(modelType: string, fieldPath: string): string | undefined;
     getModelFilterableFields(modelType: string): Set<string>;
 }

package/dist-types/models/BaseModel.d.ts

@@ -1,23 +1,25 @@
-import { NexxusApplication, NexxusApplicationModelType } from "./Application";
-import { NexxusApplicationUser, NexxusUserModelType } from "./User";
-import { NexxusAppModel, NexxusAppModelType } from "./AppModel";
-export type AnyNexxusModel = NexxusApplication | NexxusApplicationUser | NexxusAppModel;
-export type AnyNexxusModelType = NexxusApplicationModelType | NexxusUserModelType | NexxusAppModelType;
-export interface INexxusBaseModel<TType extends string = string> {
+import type { NexxusApplication, INexxusApplication } from "./Application";
+import type { NexxusUser, INexxusUser } from "./User";
+import type { NexxusAppModel, INexxusAppModel } from "./AppModel";
+export declare const MODEL_REGISTRY: {
+    readonly application: "application";
+    readonly user: "user";
+};
+export type NexxusBuiltinTypeName = typeof MODEL_REGISTRY[keyof typeof MODEL_REGISTRY];
+export type NexxusModelTypeName = NexxusBuiltinTypeName | (string & {});
+export interface INexxusBaseModel<TType extends NexxusModelTypeName = NexxusModelTypeName> {
     id?: string;
     createdAt?: number;
     updatedAt?: number;
     type: TType;
 }
-export declare const MODEL_REGISTRY: {
-    readonly application: "application";
-    readonly user: "user";
-};
-export type NexxusBuiltinModelTypeName = typeof MODEL_REGISTRY[keyof typeof MODEL_REGISTRY];
-export type NexxusModelTypeName = NexxusBuiltinModelTypeName | string;
 export declare abstract class NexxusBaseModel<T extends INexxusBaseModel = INexxusBaseModel> {
     protected data: T;
     static readonly modelType: string | undefined;
     constructor(data: T);
     getData(): T;
 }
+export type AnyNexxusBuiltinModel = NexxusApplication | NexxusUser;
+export type AnyNexxusBuiltinModelData = INexxusApplication | INexxusUser;
+export type AnyNexxusModel = AnyNexxusBuiltinModel | NexxusAppModel;
+export type AnyNexxusModelData = AnyNexxusBuiltinModelData | INexxusAppModel;

package/dist-types/models/BuiltinModel.d.ts

@@ -0,0 +1,3 @@
+import { NexxusBaseModel, INexxusBaseModel, NexxusBuiltinTypeName } from "./BaseModel";
+export declare abstract class NexxusBuiltinModel<T extends INexxusBaseModel<NexxusBuiltinTypeName>> extends NexxusBaseModel<T> {
+}

package/dist-types/models/User.d.ts

@@ -1,17 +1,19 @@
-import { NexxusBaseModel, INexxusBaseModel } from "./BaseModel";
-import { NexxusFieldDef } from "../common/ModelTypes";
-export type NexxusUserModelType = INexxusBaseModel<'user'> & {
-    appId: string;
-    userType: string;
-    username: string;
-    password: string | null;
-    authProviders: Array<string>;
-    devices: Array<string>;
-    details?: Record<string, any>;
-};
+import { INexxusBaseModel } from "./BaseModel";
+import { NexxusBuiltinModel } from "./BuiltinModel";
+import { NexxusFieldDef, NexxusModelDef } from "../common/ModelTypes";
+import { InferModel } from "../common/InferModel";
+import { NEXXUS_BUILTIN_MODEL_SCHEMAS } from "../common/BuiltinSchemas";
 export interface NexxusUserDetailSchema {
     [field: string]: NexxusFieldDef;
 }
-export declare class NexxusApplicationUser extends NexxusBaseModel<NexxusUserModelType> {
-    constructor(data: NexxusUserModelType);
+export type INexxusUser = INexxusBaseModel<'user'> & InferModel<typeof NEXXUS_BUILTIN_MODEL_SCHEMAS.user> & {
+    details?: Record<string, any>;
+};
+export declare class NexxusUser extends NexxusBuiltinModel<INexxusUser> {
+    /**
+     * Runtime field schema for User records. Optionally overlays a per-userType
+     * detail schema (resolved from the owning application) into `details.properties`.
+     */
+    static getModelSchema(userDetails?: NexxusUserDetailSchema | null): NexxusModelDef;
+    constructor(data: INexxusUser);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mayhem93/nexxus-core-lib",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Core types and structures used by other Nexxus packages",
   "main": "dist-cjs/index.js",
   "module": "dist-esm/index.js",
@@ -17,7 +17,7 @@
     "dist-*/**",
     "src/schemas/**/*.json"
   ],
-  "homepage": "https://github.com/Mayhem93/nexxus-server/tree/main/src/core",
+  "homepage": "https://github.com/Mayhem93/nexxus-lib/tree/main/src/core",
   "keywords": ["realtime", "sync", "synchronization", "notifications", "backend", "baas"],
   "author": "Răzvan Botea <contact@razvanbotea.me>",
   "license": "MPL-2.0",
@@ -25,7 +25,7 @@
     "@tsconfig/node24": "^24.0.1",
     "@types/node": "^24.9.1",
     "concurrently": "^9.2.1",
-    "typescript": "5.9.3"
+    "typescript": "^6.0.0"
   },
   "dependencies": {
     "@types/argparse": "^2.0.17",
@@ -40,7 +40,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Mayhem93/nexxus-server.git",
+    "url": "https://github.com/Mayhem93/nexxus-lib.git",
     "directory": "src/core"
   }
 }

package/src/schemas/winston-logger.schema.json

@@ -1,24 +1,69 @@
 {
-  "$comment": "logger",
+  "$id": "nexxus-winston-logger",
   "type": "object",
   "properties": {
     "level": {
       "type": "string",
-      "enum": ["debug", "info", "warn", "error", "critical", "alert", "emerg"]
+      "enum": ["debug", "info", "warn", "error", "critical", "alert", "emerg"],
+      "default": "info"
     },
     "logType": {
       "type": "string",
-      "enum": ["text", "json"]
+      "enum": ["text", "json"],
+      "default": "text"
     },
     "timestamps": {
-      "type": "boolean"
+      "type": "boolean",
+      "default": true
     },
     "colors": {
-      "type": "boolean"
+      "type": "boolean",
+      "default": false
+    },
+    "transports": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          { "$ref": "#/definitions/StdoutTransport" },
+          { "$ref": "#/definitions/FileTransport" },
+          { "$ref": "#/definitions/CustomTransport" }
+        ]
+      }
     }
   },
   "required": [
     "level",
     "logType"
-  ]
+  ],
+  "definitions": {
+    "StdoutTransport": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "stdout" }
+      },
+      "required": ["type"],
+      "additionalProperties": false
+    },
+    "FileTransport": {
+      "type": "object",
+      "properties": {
+        "type":     { "const": "file" },
+        "filename": { "type": "string" },
+        "maxSize":  { "type": "number" },
+        "maxFiles": { "type": "number" }
+      },
+      "required": ["type", "filename"],
+      "additionalProperties": false
+    },
+    "CustomTransport": {
+      "type": "object",
+      "properties": {
+        "type":    { "type": "string", "not": { "enum": ["stdout", "file"] } },
+        "export":  { "type": "string" },
+        "options": { "type": "object" }
+      },
+      "required": ["type"],
+      "additionalProperties": false
+    }
+  }
 }