@epsilon-asi/foundation 0.0.1-rc3 → 0.0.2

package/build/decorators/environment/index.d.ts

@@ -0,0 +1,164 @@
+import type { ClassDecoratorDefinition, Constructor, DecoratorRegistry, PropertyDecoratorDefinition, RegistryMetadataSnapshot } from '../factory';
+export type EnvPrimitive = string | number | boolean;
+export type EnvPrimitiveOrUndefined = EnvPrimitive | undefined;
+export type EnvBooleanTrueValue = 'true' | '1' | 'yes' | 'y' | 'on';
+export type EnvBooleanFalseValue = 'false' | '0' | 'no' | 'n' | 'off';
+export type EnvValueKind = 'string' | 'number' | 'boolean';
+export interface EnvConfigMetadata {
+    /**
+     * Optional prefix applied to every variable lookup.
+     *
+     * Example:
+     * prefix: 'APP_'
+     * @EnvVar.string('PORT')
+     * final lookup key: APP_PORT
+     */
+    prefix?: string;
+    /** Optional human-readable description for docs/debug output. */
+    description?: string;
+}
+export type StringEnvVarMetadata = {
+    type: 'string';
+    name?: string;
+    required?: boolean;
+    default?: string;
+    description?: string;
+};
+export type NumberEnvVarMetadata = {
+    type: 'number';
+    name?: string;
+    required?: boolean;
+    default?: number;
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    description?: string;
+};
+export type BooleanEnvVarMetadata = {
+    type: 'boolean';
+    name?: string;
+    required?: boolean;
+    default?: boolean;
+    description?: string;
+};
+export type EnvVarMetadata = StringEnvVarMetadata | NumberEnvVarMetadata | BooleanEnvVarMetadata;
+export type EnvDecoratorSchema = {
+    class: {
+        envConfig: ClassDecoratorDefinition<EnvConfigMetadata | undefined>;
+    };
+    property: {
+        envVar: PropertyDecoratorDefinition<EnvVarMetadata, EnvPrimitiveOrUndefined>;
+    };
+    method: {};
+    accessor: {};
+};
+export type EnvSource = Record<string, string | undefined>;
+export interface LoadEnvOptions {
+    /**
+     * Defaults to globalThis.process.env when available.
+     * Pass this in tests to avoid mutating or depending on the real process env.
+     */
+    source?: EnvSource;
+    /**
+     * Whether @EnvVar fields must be static.
+     *
+     * Defaults to true because loadEnv mutates the class constructor in place.
+     */
+    requireStatic?: boolean;
+    /**
+     * Whether empty strings and whitespace-only strings should be treated as missing.
+     *
+     * Defaults to true.
+     */
+    emptyStringAsMissing?: boolean;
+    /**
+     * Whether inherited metadata should be loaded.
+     *
+     * Defaults to true.
+     */
+    includeInherited?: boolean;
+}
+export interface DescribeEnvOptions {
+    /** Defaults to true. */
+    includeInherited?: boolean;
+}
+export interface EnvVariableDefinition {
+    readonly propertyName: string;
+    readonly envName: string;
+    readonly static: boolean;
+    readonly private: boolean;
+    readonly metadata: EnvVarMetadata;
+}
+export interface EnvLoadResult<TClass extends Constructor> {
+    readonly target: TClass;
+    readonly definitions: readonly EnvVariableDefinition[];
+    readonly values: Readonly<Record<string, EnvPrimitiveOrUndefined>>;
+    readonly snapshot: RegistryMetadataSnapshot;
+}
+export declare class EnvParseError extends Error {
+    readonly envName?: string;
+    readonly propertyName?: string;
+    constructor(message: string, details?: {
+        envName?: string;
+        propertyName?: string;
+    });
+}
+export interface EnvConfigDecorator {
+    (metadata?: EnvConfigMetadata): <TClass extends Constructor>(value: TClass, context: ClassDecoratorContext<TClass>) => void;
+}
+export interface EnvVarDecoratorApi {
+    /**
+     * Generic form:
+     *
+     * @EnvVar({ name: 'PORT', type: 'number' })
+     * static port: number;
+     */
+    (metadata: StringEnvVarMetadata): (value: undefined, context: ClassFieldDecoratorContext<any, string | undefined>) => void;
+    (metadata: NumberEnvVarMetadata): (value: undefined, context: ClassFieldDecoratorContext<any, number | undefined>) => void;
+    (metadata: BooleanEnvVarMetadata): (value: undefined, context: ClassFieldDecoratorContext<any, boolean | undefined>) => void;
+    /**
+     * @EnvVar.string('API_KEY')
+     * static apiKey: string;
+     */
+    string(name?: string, options?: Omit<StringEnvVarMetadata, 'type' | 'name'>): (value: undefined, context: ClassFieldDecoratorContext<any, string | undefined>) => void;
+    /**
+     * @EnvVar.number('PORT', { default: 3000, integer: true })
+     * static port: number;
+     */
+    number(name?: string, options?: Omit<NumberEnvVarMetadata, 'type' | 'name'>): (value: undefined, context: ClassFieldDecoratorContext<any, number | undefined>) => void;
+    /**
+     * @EnvVar.boolean('DEBUG', { default: false })
+     * static debug: boolean;
+     */
+    boolean(name?: string, options?: Omit<BooleanEnvVarMetadata, 'type' | 'name'>): (value: undefined, context: ClassFieldDecoratorContext<any, boolean | undefined>) => void;
+}
+export interface EnvSystem {
+    readonly registry: DecoratorRegistry<EnvDecoratorSchema>;
+    /** Preferred class decorator name. */
+    readonly Env: EnvConfigDecorator;
+    /** Alias for Env, for users who prefer a more explicit name. */
+    readonly EnvConfig: EnvConfigDecorator;
+    readonly EnvVar: EnvVarDecoratorApi;
+    /**
+     * Mutates the provided class in place by assigning parsed values to static fields.
+     */
+    loadEnv<TClass extends Constructor>(target: TClass, options?: LoadEnvOptions): EnvLoadResult<TClass>;
+    /** Reads env metadata without mutating the class. */
+    describeEnv<TClass extends Constructor>(target: TClass, options?: DescribeEnvOptions): readonly EnvVariableDefinition[];
+}
+export declare function createEnvSystem(): EnvSystem;
+export declare function getEnvConfigMetadata(snapshot: RegistryMetadataSnapshot): EnvConfigMetadata | undefined;
+export declare function toEnvKey(propertyName: string): string;
+export declare function parseEnvValue(args: {
+    envName: string;
+    propertyName: string;
+    rawValue: string | undefined;
+    metadata: EnvVarMetadata;
+    emptyStringAsMissing: boolean;
+}): EnvPrimitiveOrUndefined;
+export declare const envRegistry: DecoratorRegistry<EnvDecoratorSchema>;
+export declare const Env: EnvConfigDecorator;
+export declare const EnvConfig: EnvConfigDecorator;
+export declare const EnvVar: EnvVarDecoratorApi;
+export declare const loadEnv: <TClass extends Constructor>(target: TClass, options?: LoadEnvOptions) => EnvLoadResult<TClass>;
+export declare const describeEnv: <TClass extends Constructor>(target: TClass, options?: DescribeEnvOptions) => readonly EnvVariableDefinition[];

package/build/decorators/environment/index.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeEnv = exports.loadEnv = exports.EnvVar = exports.EnvConfig = exports.Env = exports.envRegistry = exports.EnvParseError = void 0;
+exports.createEnvSystem = createEnvSystem;
+exports.getEnvConfigMetadata = getEnvConfigMetadata;
+exports.toEnvKey = toEnvKey;
+exports.parseEnvValue = parseEnvValue;
+const factory_1 = require("../factory");
+class EnvParseError extends Error {
+    constructor(message, details = {}) {
+        super(message);
+        this.name = 'EnvParseError';
+        this.envName = details.envName;
+        this.propertyName = details.propertyName;
+    }
+}
+exports.EnvParseError = EnvParseError;
+function createEnvSystem() {
+    const registry = (0, factory_1.createDecoratorRegistry)({
+        namespace: 'env',
+    });
+    const RawEnvConfig = registry.class('envConfig');
+    const Env = ((metadata) => {
+        return metadata === undefined ? RawEnvConfig() : RawEnvConfig(metadata);
+    });
+    const EnvConfig = Env;
+    /**
+     * Broad scoped contract because this system decorates arbitrary env classes.
+     * The public EnvVar.string/number/boolean helper return types enforce the actual
+     * decorated property type.
+     */
+    const Scoped = registry.for();
+    const RawEnvVar = Scoped.property('envVar');
+    const EnvVar = ((metadata) => RawEnvVar(metadata));
+    EnvVar.string = (name, options = {}) => {
+        return RawEnvVar(Object.assign(Object.assign({}, options), { name, type: 'string' }));
+    };
+    EnvVar.number = (name, options = {}) => {
+        return RawEnvVar(Object.assign(Object.assign({}, options), { name, type: 'number' }));
+    };
+    EnvVar.boolean = (name, options = {}) => {
+        return RawEnvVar(Object.assign(Object.assign({}, options), { name, type: 'boolean' }));
+    };
+    function describeEnv(target, options = {}) {
+        var _a, _b;
+        const includeInherited = (_a = options.includeInherited) !== null && _a !== void 0 ? _a : true;
+        const snapshot = registry.read(target, { includeInherited });
+        const classMetadata = getEnvConfigMetadata(snapshot);
+        const prefix = (_b = classMetadata === null || classMetadata === void 0 ? void 0 : classMetadata.prefix) !== null && _b !== void 0 ? _b : '';
+        return Object.freeze(snapshot.propertyRecords('envVar').map((record) => {
+            var _a;
+            if (record.memberName === undefined) {
+                throw new EnvParseError('EnvVar metadata record is missing memberName.');
+            }
+            if (typeof record.memberName === 'symbol') {
+                throw new EnvParseError(`EnvVar does not support symbol member keys: ${String(record.memberName)}.`);
+            }
+            const metadata = record.metadata;
+            const propertyName = record.memberName;
+            const envName = prefix + ((_a = metadata.name) !== null && _a !== void 0 ? _a : toEnvKey(propertyName));
+            return Object.freeze({
+                propertyName,
+                envName,
+                static: record.static,
+                private: record.private,
+                metadata,
+            });
+        }));
+    }
+    function loadEnv(target, options = {}) {
+        var _a, _b, _c, _d;
+        const source = (_a = options.source) !== null && _a !== void 0 ? _a : getDefaultEnvSource();
+        const requireStatic = (_b = options.requireStatic) !== null && _b !== void 0 ? _b : true;
+        const emptyStringAsMissing = (_c = options.emptyStringAsMissing) !== null && _c !== void 0 ? _c : true;
+        const includeInherited = (_d = options.includeInherited) !== null && _d !== void 0 ? _d : true;
+        const snapshot = registry.read(target, { includeInherited });
+        const definitions = describeEnv(target, { includeInherited });
+        const values = {};
+        for (const definition of definitions) {
+            if (requireStatic && !definition.static) {
+                throw new EnvParseError(`@EnvVar field "${definition.propertyName}" must be static when using loadEnv().`, {
+                    envName: definition.envName,
+                    propertyName: definition.propertyName,
+                });
+            }
+            if (definition.private) {
+                throw new EnvParseError(`@EnvVar field "${definition.propertyName}" cannot be private.`, {
+                    envName: definition.envName,
+                    propertyName: definition.propertyName,
+                });
+            }
+            const rawValue = source[definition.envName];
+            const parsedValue = parseEnvValue({
+                envName: definition.envName,
+                propertyName: definition.propertyName,
+                rawValue,
+                metadata: definition.metadata,
+                emptyStringAsMissing,
+            });
+            Object.defineProperty(target, definition.propertyName, {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value: parsedValue,
+            });
+            values[definition.propertyName] = parsedValue;
+        }
+        return Object.freeze({
+            target,
+            definitions,
+            values: Object.freeze(Object.assign({}, values)),
+            snapshot,
+        });
+    }
+    return Object.freeze({
+        registry,
+        Env,
+        EnvConfig,
+        EnvVar,
+        loadEnv,
+        describeEnv,
+    });
+}
+function getEnvConfigMetadata(snapshot) {
+    const configRecords = snapshot.classRecords('envConfig');
+    const lastRecord = configRecords[configRecords.length - 1];
+    return lastRecord === null || lastRecord === void 0 ? void 0 : lastRecord.metadata;
+}
+function toEnvKey(propertyName) {
+    return propertyName
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[-\s]+/g, '_')
+        .toUpperCase();
+}
+function parseEnvValue(args) {
+    const { envName, propertyName, rawValue, metadata, emptyStringAsMissing } = args;
+    const missing = rawValue === undefined || (emptyStringAsMissing && rawValue.trim() === '');
+    if (missing) {
+        if ('default' in metadata)
+            return metadata.default;
+        if (metadata.required === false)
+            return undefined;
+        throw new EnvParseError(`Missing required environment variable "${envName}".`, {
+            envName,
+            propertyName,
+        });
+    }
+    switch (metadata.type) {
+        case 'string':
+            return rawValue;
+        case 'number':
+            return parseNumberValue({
+                envName,
+                propertyName,
+                rawValue,
+                metadata,
+            });
+        case 'boolean':
+            return parseBooleanValue({
+                envName,
+                propertyName,
+                rawValue,
+            });
+        default:
+            return assertNever(metadata);
+    }
+}
+function parseNumberValue(args) {
+    const { envName, propertyName, rawValue, metadata } = args;
+    const value = Number(rawValue);
+    if (!Number.isFinite(value)) {
+        throw new EnvParseError(`Environment variable "${envName}" must be a finite number. Received "${rawValue}".`, { envName, propertyName });
+    }
+    if (metadata.integer === true && !Number.isInteger(value)) {
+        throw new EnvParseError(`Environment variable "${envName}" must be an integer. Received "${rawValue}".`, { envName, propertyName });
+    }
+    if (metadata.min !== undefined && value < metadata.min) {
+        throw new EnvParseError(`Environment variable "${envName}" must be >= ${metadata.min}. Received "${rawValue}".`, { envName, propertyName });
+    }
+    if (metadata.max !== undefined && value > metadata.max) {
+        throw new EnvParseError(`Environment variable "${envName}" must be <= ${metadata.max}. Received "${rawValue}".`, { envName, propertyName });
+    }
+    return value;
+}
+function parseBooleanValue(args) {
+    const { envName, propertyName, rawValue } = args;
+    const normalized = rawValue.trim().toLowerCase();
+    if (isTruthyEnvValue(normalized))
+        return true;
+    if (isFalsyEnvValue(normalized))
+        return false;
+    throw new EnvParseError(`Environment variable "${envName}" must be a boolean. Received "${rawValue}".`, { envName, propertyName });
+}
+function isTruthyEnvValue(value) {
+    return value === 'true'
+        || value === '1'
+        || value === 'yes'
+        || value === 'y'
+        || value === 'on';
+}
+function isFalsyEnvValue(value) {
+    return value === 'false'
+        || value === '0'
+        || value === 'no'
+        || value === 'n'
+        || value === 'off';
+}
+function getDefaultEnvSource() {
+    var _a, _b;
+    const maybeGlobal = globalThis;
+    return (_b = (_a = maybeGlobal.process) === null || _a === void 0 ? void 0 : _a.env) !== null && _b !== void 0 ? _b : {};
+}
+function assertNever(value) {
+    throw new EnvParseError(`Unsupported env metadata: ${JSON.stringify(value)}`);
+}
+const defaultEnvSystem = createEnvSystem();
+exports.envRegistry = defaultEnvSystem.registry;
+exports.Env = defaultEnvSystem.Env;
+exports.EnvConfig = defaultEnvSystem.EnvConfig;
+exports.EnvVar = defaultEnvSystem.EnvVar;
+exports.loadEnv = defaultEnvSystem.loadEnv;
+exports.describeEnv = defaultEnvSystem.describeEnv;

package/build/decorators/factory/examples/authorization.d.ts

@@ -0,0 +1,48 @@
+type Role = 'admin' | 'support' | 'user';
+type AuthorizationDecorators = {
+    class: {
+        resource: {
+            metadata: {
+                name: string;
+            };
+        };
+    };
+    property: {};
+    method: {
+        requireRole: {
+            metadata: {
+                roles: Role[];
+            };
+            target: (...args: any[]) => Promise<unknown>;
+        };
+    };
+    accessor: {};
+};
+type AccountAdminContract = {
+    viewAccount(id: string): Promise<{
+        id: string;
+    }>;
+    suspendAccount(id: string): Promise<{
+        id: string;
+        suspended: true;
+    }>;
+};
+declare const registry: import("../types").DecoratorRegistry<AuthorizationDecorators>;
+declare class AccountAdminController implements AccountAdminContract {
+    viewAccount(id: string): Promise<{
+        id: string;
+    }>;
+    suspendAccount(id: string): Promise<{
+        id: string;
+        suspended: true;
+    }>;
+}
+export type AccessPolicy = {
+    resource: string;
+    permissions: Array<{
+        handlerName: string | symbol;
+        roles: Role[];
+    }>;
+};
+export declare function buildAccessPolicy(): AccessPolicy;
+export { AccountAdminController, registry as authorizationRegistry };

package/build/decorators/factory/examples/authorization.js

@@ -0,0 +1,113 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorizationRegistry = exports.AccountAdminController = void 0;
+exports.buildAccessPolicy = buildAccessPolicy;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'authorization-example' });
+exports.authorizationRegistry = registry;
+const Account = registry.for();
+const Resource = Account.class('resource');
+const RequireRole = Account.method('requireRole');
+let AccountAdminController = (() => {
+    let _classDecorators = [Resource({ name: 'account' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _viewAccount_decorators;
+    let _suspendAccount_decorators;
+    var AccountAdminController = _classThis = class {
+        viewAccount(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id };
+            });
+        }
+        suspendAccount(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id, suspended: true };
+            });
+        }
+        constructor() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+    __setFunctionName(_classThis, "AccountAdminController");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _viewAccount_decorators = [RequireRole.on('viewAccount', { roles: ['support', 'admin'] })];
+        _suspendAccount_decorators = [RequireRole('suspendAccount', { roles: ['admin'] })];
+        __esDecorate(_classThis, null, _viewAccount_decorators, { kind: "method", name: "viewAccount", static: false, private: false, access: { has: obj => "viewAccount" in obj, get: obj => obj.viewAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _suspendAccount_decorators, { kind: "method", name: "suspendAccount", static: false, private: false, access: { has: obj => "suspendAccount" in obj, get: obj => obj.suspendAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        AccountAdminController = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return AccountAdminController = _classThis;
+})();
+exports.AccountAdminController = AccountAdminController;
+function buildAccessPolicy() {
+    const snapshot = registry.read(AccountAdminController);
+    const resource = snapshot.firstClass('resource');
+    if (resource === undefined)
+        throw new Error('Missing @Resource metadata.');
+    return {
+        resource: resource.metadata.name,
+        permissions: snapshot.methodRecords('requireRole').map((record) => {
+            if (record.memberName === undefined)
+                throw new Error('Role record missing member.');
+            const metadata = record.metadata;
+            return {
+                handlerName: record.memberName,
+                roles: metadata.roles,
+            };
+        }),
+    };
+}

package/build/decorators/factory/examples/runExamples.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const accessors_1 = require("./accessors");
+const authorization_1 = require("./authorization");
 const crud_1 = require("./crud");
 const orm_1 = require("./orm");
 const routing_1 = require("./routing");
 const serialization_1 = require("./serialization");
+const validation_1 = require("./validation");
 function stable(value) {
     return JSON.stringify(value, (_key, innerValue) => {
         if (typeof innerValue === 'symbol')
@@ -18,5 +20,7 @@ const outputs = {
     serialization: (0, serialization_1.serializeUser)(),
     crud: (0, crud_1.buildCrudSummary)(),
     accessors: (0, accessors_1.readAccessorMetadata)(),
+    validation: (0, validation_1.buildValidationSchema)(),
+    authorization: (0, authorization_1.buildAccessPolicy)(),
 };
 console.log(stable(outputs));

package/build/decorators/factory/examples/validation.d.ts

@@ -0,0 +1,49 @@
+type ValidationDecorators = {
+    class: {
+        schema: {
+            metadata: {
+                name: string;
+            };
+        };
+    };
+    property: {
+        field: {
+            metadata: {
+                type: 'string' | 'number' | 'email';
+                minLength?: number;
+                min?: number;
+            };
+            target: unknown;
+        };
+        required: {
+            metadata: undefined;
+            target: unknown;
+        };
+    };
+    method: {};
+    accessor: {};
+};
+type SignupInputContract = {
+    email: string;
+    displayName: string;
+    age: number;
+};
+declare const registry: import("../types").DecoratorRegistry<ValidationDecorators>;
+declare class SignupInput implements SignupInputContract {
+    email: string;
+    displayName: string;
+    age: number;
+}
+export type ValidationField = {
+    name: string | symbol;
+    type: 'string' | 'number' | 'email';
+    required: boolean;
+    minLength?: number;
+    min?: number;
+};
+export type ValidationSchema = {
+    name: string;
+    fields: ValidationField[];
+};
+export declare function buildValidationSchema(): ValidationSchema;
+export { SignupInput, registry as validationRegistry };