@avleon/core 0.0.46 → 0.0.49

package/dist/openapi.d.ts

@@ -1,410 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface InfoObject {
-    title: string;
-    description?: string;
-    termsOfService?: string;
-    contact?: ContactObject;
-    license?: LicenseObject;
-    version: string;
-}
-export interface ContactObject {
-    name?: string;
-    url?: string;
-    email?: string;
-}
-export interface LicenseObject {
-    name: string;
-    url?: string;
-}
-export interface ServerObject {
-    url: string;
-    description?: string;
-    variables?: {
-        [variable: string]: ServerVariableObject;
-    };
-}
-export interface ServerVariableObject {
-    enum?: string[];
-    default: string;
-    description?: string;
-}
-export type OpenApiUiOptions = {
-    logo?: any;
-    theme?: any;
-    provider?: "default" | "scalar";
-    ui?: "default" | "scalar";
-    openapi?: string;
-    uiConfig?: any;
-    configuration?: any;
-    routePrefix?: string;
-    info?: InfoObject;
-    servers?: ServerObject[];
-    paths?: PathsObject<any>;
-    components?: ComponentsObject;
-    security?: SecurityRequirementObject[];
-    tags?: TagObject[];
-    externalDocs?: any;
-    "x-express-openapi-additional-middleware"?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
-    "x-express-openapi-validation-strict"?: boolean;
-};
-export interface PathsObject<T extends {} = {}, P extends {} = {}> {
-    [pattern: string]: (PathItemObject<T> & P) | undefined;
-}
-declare enum HttpMethods {
-    GET = "get",
-    PUT = "put",
-    POST = "post",
-    DELETE = "delete",
-    OPTIONS = "options",
-    HEAD = "head",
-    PATCH = "patch",
-    TRACE = "trace"
-}
-export type PathItemObject<T extends {} = {}> = {
-    $ref?: string;
-    summary?: string;
-    description?: string;
-    servers?: ServerObject[];
-    parameters?: (ReferenceObject | ParameterObject)[];
-} & {
-    [method in HttpMethods]?: OperationObject<T>;
-};
-export type OperationObject<T extends {} = {}> = {
-    tags?: string[];
-    summary?: string;
-    description?: string;
-    externalDocs?: ExternalDocumentationObject;
-    operationId?: string;
-    parameters?: (ReferenceObject | ParameterObject)[];
-    requestBody?: ReferenceObject | RequestBodyObject;
-    responses: ResponsesObject;
-    callbacks?: {
-        [callback: string]: ReferenceObject | CallbackObject;
-    };
-    deprecated?: boolean;
-    security?: SecurityRequirementObject[];
-    servers?: ServerObject[];
-} & T;
-export interface ExternalDocumentationObject {
-    description?: string;
-    url: string;
-}
-export interface ParameterObject extends ParameterBaseObject {
-    name: string;
-    in: string;
-}
-export interface HeaderObject extends ParameterBaseObject {
-}
-export interface ParameterBaseObject {
-    description?: string;
-    required?: boolean;
-    deprecated?: boolean;
-    allowEmptyValue?: boolean;
-    style?: string;
-    explode?: boolean;
-    allowReserved?: boolean;
-    schema?: ReferenceObject | SchemaObject;
-    example?: any;
-    examples?: {
-        [media: string]: ReferenceObject | ExampleObject;
-    };
-    content?: {
-        [media: string]: MediaTypeObject;
-    };
-}
-export type NonArraySchemaObjectType = "boolean" | "object" | "number" | "string" | "integer";
-export type ArraySchemaObjectType = "array";
-export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
-export interface ArraySchemaObject extends BaseSchemaObject {
-    type: ArraySchemaObjectType;
-    items: ReferenceObject | SchemaObject;
-}
-export interface NonArraySchemaObject extends BaseSchemaObject {
-    type?: NonArraySchemaObjectType;
-}
-export interface BaseSchemaObject {
-    title?: string;
-    description?: string;
-    format?: string;
-    default?: any;
-    multipleOf?: number;
-    maximum?: number;
-    exclusiveMaximum?: boolean;
-    minimum?: number;
-    exclusiveMinimum?: boolean;
-    maxLength?: number;
-    minLength?: number;
-    pattern?: string;
-    additionalProperties?: boolean | ReferenceObject | SchemaObject;
-    maxItems?: number;
-    minItems?: number;
-    uniqueItems?: boolean;
-    maxProperties?: number;
-    minProperties?: number;
-    required?: string[];
-    enum?: any[];
-    properties?: {
-        [name: string]: ReferenceObject | SchemaObject;
-    };
-    allOf?: (ReferenceObject | SchemaObject)[];
-    oneOf?: (ReferenceObject | SchemaObject)[];
-    anyOf?: (ReferenceObject | SchemaObject)[];
-    not?: ReferenceObject | SchemaObject;
-    nullable?: boolean;
-    discriminator?: DiscriminatorObject;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    xml?: XMLObject;
-    externalDocs?: ExternalDocumentationObject;
-    example?: any;
-    deprecated?: boolean;
-}
-export interface DiscriminatorObject {
-    propertyName: string;
-    mapping?: {
-        [value: string]: string;
-    };
-}
-export interface XMLObject {
-    name?: string;
-    namespace?: string;
-    prefix?: string;
-    attribute?: boolean;
-    wrapped?: boolean;
-}
-export interface ReferenceObject {
-    $ref: string;
-}
-export interface ExampleObject {
-    summary?: string;
-    description?: string;
-    value?: any;
-    externalValue?: string;
-}
-export interface MediaTypeObject {
-    schema?: ReferenceObject | SchemaObject;
-    example?: any;
-    examples?: {
-        [media: string]: ReferenceObject | ExampleObject;
-    };
-    encoding?: {
-        [media: string]: EncodingObject;
-    };
-}
-export interface EncodingObject {
-    contentType?: string;
-    headers?: {
-        [header: string]: ReferenceObject | HeaderObject;
-    };
-    style?: string;
-    explode?: boolean;
-    allowReserved?: boolean;
-}
-export interface RequestBodyObject {
-    description?: string;
-    content: {
-        [media: string]: MediaTypeObject;
-    };
-    required?: boolean;
-}
-export interface ResponsesObject {
-    [code: string]: ReferenceObject | ResponseObject;
-}
-export interface ResponseObject {
-    description: string;
-    headers?: {
-        [header: string]: ReferenceObject | HeaderObject;
-    };
-    content?: {
-        [media: string]: MediaTypeObject;
-    };
-    links?: {
-        [link: string]: ReferenceObject | LinkObject;
-    };
-}
-export interface LinkObject {
-    operationRef?: string;
-    operationId?: string;
-    parameters?: {
-        [parameter: string]: any;
-    };
-    requestBody?: any;
-    description?: string;
-    server?: ServerObject;
-}
-export interface CallbackObject {
-    [url: string]: PathItemObject;
-}
-export interface SecurityRequirementObject {
-    [name: string]: string[];
-}
-export interface ComponentsObject {
-    schemas?: {
-        [key: string]: ReferenceObject | SchemaObject;
-    };
-    responses?: {
-        [key: string]: ReferenceObject | ResponseObject;
-    };
-    parameters?: {
-        [key: string]: ReferenceObject | ParameterObject;
-    };
-    examples?: {
-        [key: string]: ReferenceObject | ExampleObject;
-    };
-    requestBodies?: {
-        [key: string]: ReferenceObject | RequestBodyObject;
-    };
-    headers?: {
-        [key: string]: ReferenceObject | HeaderObject;
-    };
-    securitySchemes?: {
-        [key: string]: ReferenceObject | SecuritySchemeObject;
-    };
-    links?: {
-        [key: string]: ReferenceObject | LinkObject;
-    };
-    callbacks?: {
-        [key: string]: ReferenceObject | CallbackObject;
-    };
-}
-export type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
-export interface HttpSecurityScheme {
-    type: "http";
-    description?: string;
-    scheme: string;
-    bearerFormat?: string;
-}
-export interface ApiKeySecurityScheme {
-    type: "apiKey";
-    description?: string;
-    name: string;
-    in: string;
-}
-export interface OAuth2SecurityScheme {
-    type: "oauth2";
-    description?: string;
-    flows: {
-        implicit?: {
-            authorizationUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-        password?: {
-            tokenUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-        clientCredentials?: {
-            tokenUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-        authorizationCode?: {
-            authorizationUrl: string;
-            tokenUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-    };
-}
-export interface OpenIdSecurityScheme {
-    type: "openIdConnect";
-    description?: string;
-    openIdConnectUrl: string;
-}
-export interface TagObject {
-    name: string;
-    description?: string;
-    externalDocs?: ExternalDocumentationObject;
-}
-export type ParamSchema = {
-    type?: "string" | "number" | "integer" | "boolean" | "array";
-    description?: string;
-    example?: any;
-    required?: boolean;
-    deprecated?: boolean;
-    enum?: any[];
-    format?: string;
-    default?: any;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-};
-export type ParamsSchemaMap = Record<string, ParamSchema>;
-export type RequestBodyOptions = {
-    description?: string;
-    required?: boolean;
-    content?: {
-        [media: string]: MediaTypeObject;
-    };
-    schema?: SchemaObject | ReferenceObject;
-    example?: any;
-    examples?: Record<string, ExampleObject>;
-};
-export type ResponseBodyOptions = {
-    description?: string;
-    type?: NonArraySchemaObjectType | ArraySchemaObjectType;
-    properties?: {
-        [name: string]: ReferenceObject | SchemaObject;
-    };
-    items?: ReferenceObject | SchemaObject;
-    required?: string[];
-    schema?: SchemaObject | ReferenceObject;
-    example?: any;
-    examples?: Record<string, ExampleObject>;
-    content?: {
-        [media: string]: MediaTypeObject;
-    };
-} & Partial<BaseSchemaObject>;
-export type ResponsesOptions = {
-    [statusCode: number]: ResponseBodyOptions | ResponseObject;
-};
-export type OpenApiOptions = {
-    exclude?: boolean;
-    deprecated?: boolean;
-    tags?: readonly string[];
-    description?: string;
-    summary?: string;
-    operationId?: string;
-    security?: SecurityRequirementObject[];
-    externalDocs?: ExternalDocumentationObject;
-    components?: ComponentsObject;
-    /** Path parameters e.g. /:id → { id: { type: "string", example: "abc-123" } } */
-    params?: ParamsSchemaMap;
-    /** Query string parameters e.g. ?page=1 → { page: { type: "integer", example: 1 } } */
-    query?: ParamsSchemaMap;
-    /** Request headers */
-    headers?: ParamsSchemaMap;
-    /** Request body */
-    requestBody?: RequestBodyOptions;
-    /** Responses keyed by HTTP status code */
-    response?: ResponsesOptions;
-    /** @deprecated use requestBody instead */
-    responseBody?: any;
-};
-/**
- * Normalize a flat ParamsSchemaMap into a valid JSON Schema object
- * that Fastify/AJV can validate against.
- *
- * Input:  { id: { type: "string", example: "abc-123" } }
- * Output: { type: "object", properties: { id: { type: "string", example: "abc-123" } } }
- */
-export declare function normalizeParamsToJsonSchema(params: ParamsSchemaMap, requiredKeys?: string[]): SchemaObject;
-export declare function OpenApiSchema(): ClassDecorator;
-export declare function OpenApi(options: OpenApiOptions): MethodDecorator & ClassDecorator & PropertyDecorator;
-export {};

package/dist/openapi.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeParamsToJsonSchema = normalizeParamsToJsonSchema;
-exports.OpenApiSchema = OpenApiSchema;
-exports.OpenApi = OpenApi;
-var HttpMethods;
-(function (HttpMethods) {
-    HttpMethods["GET"] = "get";
-    HttpMethods["PUT"] = "put";
-    HttpMethods["POST"] = "post";
-    HttpMethods["DELETE"] = "delete";
-    HttpMethods["OPTIONS"] = "options";
-    HttpMethods["HEAD"] = "head";
-    HttpMethods["PATCH"] = "patch";
-    HttpMethods["TRACE"] = "trace";
-})(HttpMethods || (HttpMethods = {}));
-/**
- * Normalize a flat ParamsSchemaMap into a valid JSON Schema object
- * that Fastify/AJV can validate against.
- *
- * Input:  { id: { type: "string", example: "abc-123" } }
- * Output: { type: "object", properties: { id: { type: "string", example: "abc-123" } } }
- */
-function normalizeParamsToJsonSchema(params, requiredKeys = []) {
-    const properties = {};
-    for (const [key, val] of Object.entries(params)) {
-        properties[key] = {
-            type: "string", // sensible default
-            ...val,
-        };
-    }
-    const schema = {
-        type: "object",
-        properties,
-    };
-    if (requiredKeys.length > 0) {
-        schema.required = requiredKeys;
-    }
-    return schema;
-}
-function OpenApiSchema() {
-    return function (target) {
-        Reflect.defineMetadata("openapi:schema", true, target);
-    };
-}
-function OpenApi(options) {
-    return function (target, propertyKey, descriptor) {
-        if (typeof target === "function" && !propertyKey) {
-            Reflect.defineMetadata("controller:openapi", options, target);
-        }
-        else if (descriptor) {
-            // ✅ Store options as-is — router's buildRouteSchema handles normalization
-            Reflect.defineMetadata("route:openapi", options, target, propertyKey);
-        }
-        else if (propertyKey) {
-            Reflect.defineMetadata("property:openapi", options, target, propertyKey);
-        }
-    };
-}

package/dist/openapi.test.d.ts

@@ -1 +0,0 @@
-import 'reflect-metadata';

package/dist/openapi.test.js

@@ -1,111 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const openapi_1 = require("./openapi");
-describe('OpenApi Decorator', () => {
-    it('should define metadata on class', () => {
-        let TestController = class TestController {
-        };
-        TestController = __decorate([
-            (0, openapi_1.OpenApi)({ description: 'Test Controller' })
-        ], TestController);
-        const metadata = Reflect.getMetadata('controller:openapi', TestController);
-        expect(metadata).toEqual({ description: 'Test Controller' });
-    });
-    it('should define metadata on method', () => {
-        class TestController {
-            testMethod() { }
-        }
-        __decorate([
-            (0, openapi_1.OpenApi)({ description: 'Test Route' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", void 0)
-        ], TestController.prototype, "testMethod", null);
-        const metadata = Reflect.getMetadata('route:openapi', TestController.prototype, 'testMethod');
-        expect(metadata).toEqual({ description: 'Test Route' });
-    });
-    it('should define metadata on property', () => {
-        class TestController {
-            constructor() {
-                this.testProperty = '';
-            }
-        }
-        __decorate([
-            (0, openapi_1.OpenApi)({ description: 'Test Property' }),
-            __metadata("design:type", String)
-        ], TestController.prototype, "testProperty", void 0);
-        const metadata = Reflect.getMetadata('property:openapi', TestController.prototype, 'testProperty');
-        expect(metadata).toEqual({ description: 'Test Property' });
-    });
-});
-describe('Type Definitions', () => {
-    it('InfoObject should allow optional description', () => {
-        const info = {
-            title: 'API',
-            version: '1.0.0',
-            description: 'API Description',
-        };
-        expect(info.description).toBe('API Description');
-    });
-    it('ContactObject should allow optional fields', () => {
-        const contact = {
-            name: 'John Doe',
-            email: 'john@example.com',
-        };
-        expect(contact.name).toBe('John Doe');
-        expect(contact.email).toBe('john@example.com');
-    });
-    it('LicenseObject should require name', () => {
-        const license = {
-            name: 'MIT',
-        };
-        expect(license.name).toBe('MIT');
-    });
-    it('ServerObject should allow variables', () => {
-        var _a;
-        const server = {
-            url: 'https://api.example.com',
-            variables: {
-                version: {
-                    default: 'v1',
-                    enum: ['v1', 'v2'],
-                },
-            },
-        };
-        expect((_a = server.variables) === null || _a === void 0 ? void 0 : _a.version.default).toBe('v1');
-    });
-    it('SchemaObject should allow array and non-array types', () => {
-        const arraySchema = {
-            type: 'array',
-            items: { type: 'string' },
-        };
-        expect(arraySchema.type).toBe('array');
-        const nonArraySchema = {
-            type: 'string',
-        };
-        expect(nonArraySchema.type).toBe('string');
-    });
-    it('ComponentsObject should allow schemas and responses', () => {
-        var _a, _b;
-        const components = {
-            schemas: {
-                User: { type: 'object' },
-            },
-            responses: {
-                NotFound: { description: 'Not found' },
-            },
-        };
-        expect((_a = components.schemas) === null || _a === void 0 ? void 0 : _a.User).toBeDefined();
-        expect(((_b = components.responses) === null || _b === void 0 ? void 0 : _b.NotFound).description).toBe('Not found');
-    });
-});

package/dist/params.d.ts

@@ -1,17 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-type ParameterOptions = {
-    required?: boolean;
-    validate?: boolean;
-    type?: any;
-};
-export declare const Param: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const Query: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const Body: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const Header: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const AuthUser: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export {};

package/dist/params.js

@@ -1,64 +0,0 @@
-"use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthUser = exports.Header = exports.Body = exports.Query = exports.Param = void 0;
-const container_1 = require("./container");
-const helpers_1 = require("./helpers");
-const swagger_schema_1 = require("./swagger-schema");
-function createParamDecorator(type) {
-    return function (key, options = {}) {
-        return function (target, propertyKey, parameterIndex) {
-            var _a, _b, _c, _d;
-            let metaKey;
-            switch (type) {
-                case "route:param":
-                    metaKey = container_1.PARAM_META_KEY;
-                    break;
-                case "route:query":
-                    metaKey = container_1.QUERY_META_KEY;
-                    break;
-                case "route:body":
-                    metaKey = container_1.REQUEST_BODY_META_KEY;
-                    break;
-                case "route:user":
-                    metaKey = container_1.REQUEST_USER_META_KEY;
-                    break;
-                case "route:header":
-                    metaKey = container_1.REQUEST_HEADER_META_KEY;
-                    break;
-                default:
-                    throw new Error(`Unknown param decorator type: ${String(type)}`);
-            }
-            const existingParams = Reflect.getMetadata(metaKey, target, propertyKey) || [];
-            // Get parameter names (fallback safe)
-            const functionSource = target[propertyKey].toString();
-            const paramNames = ((_b = (_a = functionSource.match(/\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.split(",").map((n) => n.trim())) || [];
-            const parameterTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
-            const paramDataType = parameterTypes[parameterIndex];
-            existingParams.push({
-                index: parameterIndex,
-                key: typeof key === "string" ? key : "all",
-                name: paramNames[parameterIndex],
-                required: (_c = options.required) !== null && _c !== void 0 ? _c : true,
-                validate: (_d = options.validate) !== null && _d !== void 0 ? _d : true,
-                dataType: (0, helpers_1.getDataType)(paramDataType),
-                validatorClass: (0, helpers_1.isClassValidatorClass)(paramDataType),
-                schema: (0, helpers_1.isClassValidatorClass)(paramDataType)
-                    ? (0, swagger_schema_1.generateClassSchema)(paramDataType)
-                    : null,
-                type,
-            });
-            Reflect.defineMetadata(metaKey, existingParams, target, propertyKey);
-        };
-    };
-}
-exports.Param = createParamDecorator("route:param");
-exports.Query = createParamDecorator("route:query");
-exports.Body = createParamDecorator("route:body");
-exports.Header = createParamDecorator("route:header");
-exports.AuthUser = createParamDecorator("route:user");

package/dist/params.test.d.ts

@@ -1 +0,0 @@
-import "reflect-metadata";