equipped 4.4.6 → 5.0.0-beta-2

package/lib/server/middlewares/parseAuthUser.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAuthUser = void 0;
 const errors_1 = require("../../errors");
 const tokens_1 = require("../../utils/tokens");
-const controllers_1 = require("../controllers");
-exports.parseAuthUser = (0, controllers_1.makeMiddleware)(async (request) => {
+const types_1 = require("../types");
+exports.parseAuthUser = (0, types_1.makeMiddleware)(async (request) => {
     const accessToken = request.headers.AccessToken;
     if (accessToken)
         request.authUser = await (0, tokens_1.verifyAccessToken)(accessToken).catch((err) => {

package/lib/server/middlewares/requireAuthUser.d.ts

@@ -1,2 +1,4 @@
-import { Request } from '../controllers/request';
-export declare const requireAuthUser: (request: Request) => Promise<void>;
+export declare const requireAuthUser: {
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<unknown, string, import("../types").MethodTypes, unknown, unknown, unknown, import("../types").SupportedStatusCodes>>;
+    onSetup?: import("../types").HandlerSetup | undefined;
+};

package/lib/server/middlewares/requireAuthUser.js

@@ -2,10 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireAuthUser = void 0;
 const errors_1 = require("../../errors");
-const requireAuthUser = async (request) => {
+const types_1 = require("../types");
+exports.requireAuthUser = (0, types_1.makeMiddleware)(async (request) => {
     if (request.pendingError)
         throw request.pendingError;
+    if (!request.headers.AccessToken)
+        throw new errors_1.NotAuthenticatedError('Access-Token header missing');
     if (!request.authUser)
         throw new errors_1.NotAuthenticatedError();
-};
-exports.requireAuthUser = requireAuthUser;
+}, (route) => {
+    route.security ?? (route.security = []);
+    route.security.push({ AccessToken: [] });
+});

package/lib/server/middlewares/requireRefreshUser.d.ts

@@ -1,2 +1,4 @@
-import { Request } from '../controllers/request';
-export declare const requireRefreshUser: (request: Request) => Promise<void>;
+export declare const requireRefreshUser: {
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<unknown, string, import("../types").MethodTypes, unknown, unknown, unknown, import("../types").SupportedStatusCodes>>;
+    onSetup?: import("../types").HandlerSetup | undefined;
+};

package/lib/server/middlewares/requireRefreshUser.js

@@ -3,12 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireRefreshUser = void 0;
 const errors_1 = require("../../errors");
 const tokens_1 = require("../../utils/tokens");
-const requireRefreshUser = async (request) => {
+const types_1 = require("../types");
+exports.requireRefreshUser = (0, types_1.makeMiddleware)(async (request) => {
     const refreshToken = request.headers.RefreshToken;
     if (!refreshToken)
-        throw new errors_1.NotAuthorizedError();
+        throw new errors_1.NotAuthorizedError('Refresh-Token header missing');
     request.refreshUser = await (0, tokens_1.verifyRefreshToken)(refreshToken);
     if (!request.refreshUser)
         throw new errors_1.NotAuthorizedError();
-};
-exports.requireRefreshUser = requireRefreshUser;
+}, (route) => {
+    route.security ?? (route.security = []);
+    route.security.push({ RefreshToken: [] });
+});

package/lib/server/requests.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { CustomError } from '../errors';
+import { StorageFile } from '../storage';
+import { AuthUser, RefreshUser } from '../utils/authUser';
+import { Api, SupportedStatusCodes } from './types';
+type HeaderKeys = 'AccessToken' | 'RefreshToken' | 'Referer' | 'ContentType' | 'UserAgent';
+export declare class Request<Def extends Api = Api> {
+    #private;
+    private readonly response;
+    readonly ip: string | undefined;
+    readonly method: Def['method'];
+    readonly path: string;
+    readonly body: Def['body'];
+    readonly params: Def['params'];
+    readonly query: Def['query'];
+    readonly cookies: Record<string, any>;
+    readonly rawBody: unknown;
+    readonly headers: Record<HeaderKeys, string | null> & Record<string, string | string[] | null>;
+    readonly files: Record<string, StorageFile[]>;
+    authUser: null | AuthUser;
+    refreshUser: null | RefreshUser;
+    pendingError: null | CustomError;
+    constructor({ ip, body, cookies, params, query, method, path, headers, files }: {
+        ip: string | undefined;
+        body: unknown;
+        params: Def['params'];
+        query: Def['query'];
+        cookies: Record<string, any>;
+        headers: Record<HeaderKeys, string | null> & Record<string, string | string[] | null>;
+        files: Record<string, StorageFile[]>;
+        method: Def['method'];
+        path: string;
+    }, response: Writable);
+    pipe(cb: (stream: Writable) => void): Response<Writable, 200>;
+}
+export declare class Response<T, S extends SupportedStatusCodes = SupportedStatusCodes> {
+    readonly body: T | undefined;
+    readonly status: S;
+    readonly headers: Record<string, any>;
+    readonly piped: boolean;
+    constructor({ body, status, headers, piped }: {
+        body?: T;
+        status?: S;
+        headers?: Record<string, any>;
+        piped?: boolean;
+    });
+    get shouldJSONify(): boolean;
+}
+export {};

package/lib/server/requests.js

@@ -0,0 +1,60 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Request_instances, _Request_parseQueryStrings;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = exports.Request = void 0;
+const json_1 = require("../utils/json");
+const types_1 = require("./types");
+class Request {
+    constructor({ ip, body, cookies, params, query, method, path, headers, files }, response) {
+        _Request_instances.add(this);
+        this.response = response;
+        this.authUser = null;
+        this.refreshUser = null;
+        this.pendingError = null;
+        this.ip = ip;
+        this.method = method;
+        this.path = path;
+        this.rawBody = body;
+        this.body = Object.fromEntries(Object.entries(body && typeof body === 'object' ? body : { raw: body })
+            .map(([key, value]) => [key, (0, json_1.parseJSONValue)(value)]));
+        this.cookies = cookies;
+        this.params = params;
+        this.query = Object.fromEntries(Object.entries(query && typeof body === 'object' ? query : {})
+            .map(([key, val]) => [key, __classPrivateFieldGet(this, _Request_instances, "m", _Request_parseQueryStrings).call(this, val)]));
+        if (this.query?.['auth'])
+            delete this.query['auth'];
+        if (this.query?.['authType'])
+            delete this.query['authType'];
+        this.headers = headers;
+        this.files = files;
+    }
+    pipe(cb) {
+        cb(this.response);
+        return new Response({ piped: true, status: types_1.StatusCodes.Ok, body: this.response });
+    }
+}
+exports.Request = Request;
+_Request_instances = new WeakSet(), _Request_parseQueryStrings = function _Request_parseQueryStrings(value) {
+    if (Array.isArray(value))
+        return value.map(__classPrivateFieldGet(this, _Request_instances, "m", _Request_parseQueryStrings));
+    if (typeof value === 'string')
+        return (0, json_1.parseJSONValue)(value);
+    return value;
+};
+class Response {
+    constructor({ body, status = types_1.StatusCodes.Ok, headers = { 'Content-Type': 'application/json' }, piped = false }) {
+        this.body = body;
+        this.status = status;
+        this.headers = headers;
+        this.piped = piped;
+    }
+    get shouldJSONify() {
+        return this.body === null || this.body === undefined;
+    }
+}
+exports.Response = Response;

package/lib/server/routes.d.ts

@@ -1,26 +1,9 @@
-import { Controller, RouteHandler } from './controllers';
-type MethodTypes = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'all';
-export type Route = {
-    path: string;
-    method: MethodTypes;
-    controllers: Controller[];
-    global?: boolean;
-};
-export declare const formatPath: (path: string) => string;
-export declare const groupRoutes: (parent: string, routes: Route[]) => Route[];
-type RouteConfig = Partial<Omit<Route, 'method' | 'controllers'>> & {
-    middlewares?: Route['controllers'];
-};
-export declare class Router {
+import { ClassPropertiesWrapper } from 'valleyed';
+import { AddMethodImpls, GeneralConfig, Route } from './types';
+export declare const groupRoutes: (config: GeneralConfig, routes: Route[]) => Route[];
+export declare class Router extends ClassPropertiesWrapper<AddMethodImpls> {
     #private;
-    readonly routes: Route[];
-    constructor(config?: RouteConfig);
-    get(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
-    post(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
-    put(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
-    patch(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
-    delete(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
-    all(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    constructor(config?: GeneralConfig);
     include(router: Router): void;
+    get routes(): Route[];
 }
-export {};

package/lib/server/routes.js

@@ -1,69 +1,59 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Router_instances, _Router_config, _Router_addRoute;
+var _Router_instances, _Router_config, _Router_routes, _Router_children, _Router_addRoute;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = exports.groupRoutes = exports.formatPath = void 0;
-const controllers_1 = require("./controllers");
-const formatPath = (path) => `/${path}`
-    .replaceAll('///', '/')
-    .replaceAll('//', '/');
-exports.formatPath = formatPath;
-const groupRoutes = (parent, routes) => routes
-    .map((route) => ({ ...route, path: (0, exports.formatPath)(`${parent}/${route.path}`) }));
+exports.Router = exports.groupRoutes = void 0;
+const valleyed_1 = require("valleyed");
+const types_1 = require("./types");
+const groupRoutes = (config, routes) => routes
+    .map((route) => ({
+    ...config,
+    ...route,
+    path: `${config.path}/${route.path}`,
+    tags: [...(config.tags ?? []), ...(route.tags ?? [])],
+    middlewares: [...(config.middlewares ?? []), ...(route.middlewares ?? [])],
+    security: [...(config.security ?? []), ...(route.security ?? [])],
+}));
 exports.groupRoutes = groupRoutes;
-class Router {
+class Router extends valleyed_1.ClassPropertiesWrapper {
     constructor(config) {
+        const methodImpls = Object.fromEntries(Object.values(types_1.Methods).map((method) => [method, (route) => __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, method, route)]));
+        super(methodImpls);
         _Router_instances.add(this);
-        _Router_config.set(this, void 0);
-        this.routes = [];
-        __classPrivateFieldSet(this, _Router_config, config, "f");
-    }
-    get(route) {
-        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'get', route);
-    }
-    post(route) {
-        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'post', route);
-    }
-    put(route) {
-        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'put', route);
-    }
-    patch(route) {
-        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'patch', route);
-    }
-    delete(route) {
-        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'delete', route);
-    }
-    all(route) {
-        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'all', route);
+        _Router_config.set(this, { path: '' });
+        _Router_routes.set(this, []);
+        _Router_children.set(this, []);
+        if (config)
+            __classPrivateFieldSet(this, _Router_config, config, "f");
     }
     include(router) {
-        router.routes.forEach((route) => {
-            __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, route.method, route)();
+        __classPrivateFieldGet(this, _Router_children, "f").push(router);
+    }
+    get routes() {
+        const routes = __classPrivateFieldGet(this, _Router_routes, "f");
+        __classPrivateFieldGet(this, _Router_children, "f").forEach((child) => {
+            child.routes.forEach((route) => {
+                __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, route.method, route, routes)(route.handler);
+            });
         });
+        return routes;
     }
 }
 exports.Router = Router;
-_Router_config = new WeakMap(), _Router_instances = new WeakSet(), _Router_addRoute = function _Router_addRoute(method, route) {
+_Router_config = new WeakMap(), _Router_routes = new WeakMap(), _Router_children = new WeakMap(), _Router_instances = new WeakSet(), _Router_addRoute = function _Router_addRoute(method, routeConfig, collection = __classPrivateFieldGet(this, _Router_routes, "f")) {
     return (handler) => {
-        const controllers = [...(__classPrivateFieldGet(this, _Router_config, "f")?.middlewares ?? []), ...(route.middlewares ?? [])];
-        if (handler)
-            controllers.push((0, controllers_1.makeController)(handler));
-        this.routes.push({
-            ...__classPrivateFieldGet(this, _Router_config, "f"),
-            ...route,
-            method,
-            controllers,
-            path: (0, exports.formatPath)(`${__classPrivateFieldGet(this, _Router_config, "f")?.path ?? ''}/${route.path ?? ''}`),
-        });
+        const route = (0, exports.groupRoutes)(__classPrivateFieldGet(this, _Router_config, "f"), [{ ...routeConfig, method, handler }])[0];
+        collection.push(route);
+        return route;
     };
 };

package/lib/server/types.d.ts

@@ -0,0 +1,85 @@
+import { Enum } from '../enums/types';
+import { CustomError } from '../errors';
+import { FastifySchema } from 'fastify';
+import { JSONPrimitives, JSONValue } from '../types';
+import type { Request, Response } from './requests';
+export declare const Methods: {
+    readonly get: "get";
+    readonly post: "post";
+    readonly put: "put";
+    readonly patch: "patch";
+    readonly delete: "delete";
+};
+export type MethodTypes = Enum<typeof Methods>;
+export declare const StatusCodes: {
+    readonly Ok: 200;
+    readonly BadRequest: 400;
+    readonly NotAuthenticated: 401;
+    readonly NotAuthorized: 403;
+    readonly NotFound: 404;
+    readonly ValidationError: 422;
+    readonly TooManyRequests: 429;
+    readonly AccessTokenExpired: 461;
+};
+export type SupportedStatusCodes = Enum<typeof StatusCodes>;
+type GoodStatusCodes = 200;
+type ApiErrors = Record<Exclude<SupportedStatusCodes, GoodStatusCodes>, JSONValue<CustomError['serializedErrors']>>;
+type ApiResponse<T, StatusCode extends SupportedStatusCodes> = Record<StatusCode, JSONValue<T>> | Omit<ApiErrors, StatusCode>;
+type Any = object | unknown;
+type Arrayable<T> = T | T[];
+type AllowedResponses = Arrayable<JSONPrimitives | Any>;
+export type Api<Res = AllowedResponses, Key extends string = string, Method extends MethodTypes = MethodTypes, Body extends Any = Any, Params extends Any = Any, Query extends Any = Any, DefaultStatus extends SupportedStatusCodes = SupportedStatusCodes> = {
+    key: Key;
+    method: Method;
+    response: Res;
+    body?: Body;
+    params?: Params;
+    query?: Query;
+    defaultStatusCode?: DefaultStatus;
+};
+export type ApiDef<T extends Api = Api> = {
+    key: T['key'];
+    method: T['method'];
+    body: T['body'];
+    params: T['params'];
+    query: T['query'];
+    responses: ApiResponse<T['response'], GetDefaultStatusCode<T['defaultStatusCode']>>;
+    __api?: T;
+};
+type Awaitable<T> = Promise<T> | T;
+type Res<T, S extends SupportedStatusCodes> = Awaitable<Response<T, S> | T>;
+type InferApiFromApiDef<T> = T extends ApiDef<infer A> ? A : never;
+type GetDefaultStatusCode<T extends Api['defaultStatusCode']> = T extends SupportedStatusCodes ? T : 200;
+export type RouteHandler<Def extends Api = Api> = (req: Request<Def>) => Res<Def['response'], GetDefaultStatusCode<Def['defaultStatusCode']>>;
+export type ErrorHandler<Def extends Api = Api> = (req: Request<Def>, err: Error) => Res<CustomError['serializedErrors'], GetDefaultStatusCode<Def['defaultStatusCode']>>;
+export type RouteMiddlewareHandler<Def extends Api = Api> = (req: Request<Def>) => Awaitable<void>;
+export type HandlerSetup = (route: Route) => void;
+export type RouteSchema = Omit<FastifySchema, 'tags' | 'security' | 'hide'>;
+export type Route<Def extends ApiDef = ApiDef> = {
+    key?: Def['key'];
+    path: string;
+    method: Def['method'];
+    handler: RouteHandler<InferApiFromApiDef<Def>>;
+    onSetupHandler?: HandlerSetup;
+    middlewares?: ReturnType<typeof makeMiddleware>[];
+    onError?: ReturnType<typeof makeErrorMiddleware>;
+    schema?: RouteSchema;
+    tags?: string[];
+    hideSchema?: boolean;
+    security?: Record<string, string[]>[];
+    __def?: Def;
+};
+export type RouteConfig<T extends ApiDef = ApiDef> = Omit<Route<T>, 'method' | 'handler'>;
+export type GeneralConfig = Omit<RouteConfig, 'schema' | 'key'>;
+export type AddMethodImpls = {
+    [Method in MethodTypes]: <T extends ApiDef<Api<AllowedResponses, string, Method>>>(route: RouteConfig<T>) => (handler: RouteHandler<InferApiFromApiDef<T>>) => Route<T>;
+};
+declare class MiddlewareHandler<Cb extends Function> {
+    cb: Cb;
+    onSetup?: HandlerSetup | undefined;
+    private constructor();
+    static make<Cb extends Function>(cb: Cb, onSetup?: HandlerSetup): MiddlewareHandler<Cb>;
+}
+export declare const makeMiddleware: <Def extends Api<unknown, string, MethodTypes, unknown, unknown, unknown, SupportedStatusCodes> = Api<unknown, string, MethodTypes, unknown, unknown, unknown, SupportedStatusCodes>>(cb: RouteMiddlewareHandler<Def>, onSetup?: HandlerSetup | undefined) => MiddlewareHandler<RouteMiddlewareHandler<Def>>;
+export declare const makeErrorMiddleware: <Def extends Api<unknown, string, MethodTypes, unknown, unknown, unknown, SupportedStatusCodes> = Api<unknown, string, MethodTypes, unknown, unknown, unknown, SupportedStatusCodes>>(cb: ErrorHandler<Def>, onSetup?: HandlerSetup | undefined) => MiddlewareHandler<ErrorHandler<Def>>;
+export {};

package/lib/server/types.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeErrorMiddleware = exports.makeMiddleware = exports.StatusCodes = exports.Methods = void 0;
+exports.Methods = {
+    get: 'get',
+    post: 'post',
+    put: 'put',
+    patch: 'patch',
+    delete: 'delete',
+};
+exports.StatusCodes = {
+    Ok: 200,
+    BadRequest: 400,
+    NotAuthenticated: 401,
+    NotAuthorized: 403,
+    NotFound: 404,
+    ValidationError: 422,
+    TooManyRequests: 429,
+    AccessTokenExpired: 461,
+};
+class MiddlewareHandler {
+    constructor(cb, onSetup) {
+        this.cb = cb;
+        this.onSetup = onSetup;
+    }
+    static make(cb, onSetup) {
+        return new MiddlewareHandler(cb, onSetup);
+    }
+}
+const makeMiddleware = (...args) => MiddlewareHandler.make(...args);
+exports.makeMiddleware = makeMiddleware;
+const makeErrorMiddleware = (...args) => MiddlewareHandler.make(...args);
+exports.makeErrorMiddleware = makeErrorMiddleware;

package/lib/structure/baseEntity.d.ts

@@ -1,9 +1,8 @@
 import { ClassPropertiesWrapper } from 'valleyed';
-export declare class BaseEntity<Keys extends Record<string, any>> extends ClassPropertiesWrapper<Keys> {
-    hash: string;
-    ignoreInJSON: string[];
+export declare class BaseEntity<Keys extends object = object, Ignored extends string = string> extends ClassPropertiesWrapper<Keys> {
+    __hash: string;
     __type: string;
-    constructor(keys: Keys);
+    readonly __ignoreInJSON: Ignored[];
     toJSON(includeIgnored?: boolean): Record<string, any>;
-    toString(): string;
+    toString(includeIgnored?: boolean): string;
 }

package/lib/structure/baseEntity.js

@@ -6,27 +6,35 @@ const utils_1 = require("../utils/utils");
 const deleteKeyFromObject = (obj, keys) => {
     if (obj === undefined || obj === null)
         return;
-    if (keys.length === 1)
+    const isArray = Array.isArray(obj);
+    if (keys.length === 1 && !isArray)
         return delete obj[keys[0]];
-    const key = keys.pop() ?? '';
-    return deleteKeyFromObject(obj[key], keys);
+    if (isArray)
+        return obj.map((v) => deleteKeyFromObject(v, keys));
+    return deleteKeyFromObject(obj[keys[0]], keys.slice(1));
 };
 class BaseEntity extends valleyed_1.ClassPropertiesWrapper {
-    constructor(keys) {
-        super(keys);
-        this.ignoreInJSON = [];
+    constructor() {
+        super(...arguments);
+        this.__hash = utils_1.Random.string();
         this.__type = this.constructor.name;
-        this.hash = utils_1.Random.string();
+        this.__ignoreInJSON = [];
     }
     toJSON(includeIgnored = false) {
-        const json = super.toJSON();
+        const json = {};
+        Object.keys(this)
+            .concat(Object.getOwnPropertyNames(Object.getPrototypeOf(this)))
+            .filter((k) => k !== 'constructor')
+            .forEach((key) => {
+            const value = this[key];
+            json[key] = value?.toJSON?.(includeIgnored) ?? structuredClone(value);
+        });
         if (!includeIgnored)
-            this.ignoreInJSON.forEach((k) => deleteKeyFromObject(json, k.split('.').reverse()));
-        delete json.ignoreInJSON;
+            this.__ignoreInJSON.concat('__ignoreInJSON').forEach((k) => deleteKeyFromObject(json, k.split('.')));
         return json;
     }
-    toString() {
-        return JSON.stringify(this.toJSON(true));
+    toString(includeIgnored = true) {
+        return JSON.stringify(this.toJSON(includeIgnored), null, 2);
     }
 }
 exports.BaseEntity = BaseEntity;

package/lib/types/index.d.ts

@@ -0,0 +1,20 @@
+import { BaseEntity } from '../structure';
+export type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export type DeepOmit<T, K, A = never> = T extends any[] ? DeepOmit<T[number], K, A>[] : T extends (...args: any[]) => any ? never : T extends Array<infer U> ? DeepOmit<U, K, A>[] : {
+    [P in keyof T as P extends K | A ? never : P]: DeepOmit<T[P], K extends `${Exclude<P, symbol>}.${infer R}` ? R : never, A>;
+};
+export type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+export type Defined<T> = T extends undefined ? never : T;
+type StopTypes = number | string | boolean | symbol | bigint | Date;
+type ExcludedTypes = (...args: any[]) => any;
+type Dot<T extends string, U extends string> = '' extends U ? T : `${T}.${U}`;
+export type Paths<T, D = never> = T extends StopTypes ? '' : T extends readonly unknown[] ? Paths<T[number]> : {
+    [K in keyof T & string]: T[K] extends StopTypes ? K : T[K] extends ExcludedTypes ? D : K | Dot<K, Paths<T[K]>>;
+}[keyof T & string];
+export type JSONPrimitives = string | number | boolean | null;
+export type JSONValue<T> = T extends JSONPrimitives ? T : T extends Array<infer U> ? JSONValue<U>[] : T extends BaseEntity<infer _M, infer I> ? JSONValue<DeepOmit<T, I, '__ignoreInJSON'>> : T extends Function ? never : T extends object ? {
+    [K in keyof T & (number | string) as JSONValue<T[K]> extends never ? never : JSONValue<T[K]> extends undefined ? never : K]: JSONValue<T[K]>;
+} : T extends unknown ? unknown : undefined extends T ? JSONValue<Exclude<T, undefined>> | undefined : never;
+export {};

package/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/validations/index.d.ts

@@ -154,7 +154,7 @@ export declare const Validation: {
         ignored: boolean;
     };
 };
-export declare const validate: <T extends Record<string, Validate.VCore<any>>>(schema: T, value: Record<string, any>) => { [K in keyof T]: import("valleyed/lib/api/base").ExtractI<T[K]>; };
+export declare const validate: <T extends Record<string, Validate.VCore<any>>>(schema: T, value: unknown) => { [K in keyof T]: import("valleyed/lib/api/base").ExtractI<T[K]>; };
 export declare const Hash: {
     hash: (password: string) => Promise<string>;
     compare: (plainPassword: string, hashed: string) => Promise<boolean>;