@avleon/core 0.0.4

package/dist/openapi.d.ts

@@ -0,0 +1,333 @@
+interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+interface LicenseObject {
+    name: string;
+    url?: string;
+}
+interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+        [variable: string]: ServerVariableObject;
+    };
+}
+interface ServerVariableObject {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+export type OpenApiUiOptions = {
+    openapi?: string;
+    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;
+};
+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"
+}
+type PathItemObject<T extends {} = {}> = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+} & {
+    [method in HttpMethods]?: OperationObject<T>;
+};
+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;
+interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+interface ParameterObject extends ParameterBaseObject {
+    name: string;
+    in: string;
+}
+interface HeaderObject extends ParameterBaseObject {
+}
+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;
+    };
+}
+type NonArraySchemaObjectType = "boolean" | "object" | "number" | "string" | "integer";
+type ArraySchemaObjectType = "array";
+type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+}
+interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+}
+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;
+}
+interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+        [value: string]: string;
+    };
+}
+interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+interface ReferenceObject {
+    $ref: string;
+}
+interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+interface MediaTypeObject {
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+        [media: string]: ReferenceObject | ExampleObject;
+    };
+    encoding?: {
+        [media: string]: EncodingObject;
+    };
+}
+interface EncodingObject {
+    contentType?: string;
+    headers?: {
+        [header: string]: ReferenceObject | HeaderObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+interface RequestBodyObject {
+    description?: string;
+    content: {
+        [media: string]: MediaTypeObject;
+    };
+    required?: boolean;
+}
+interface ResponsesObject {
+    [code: string]: ReferenceObject | ResponseObject;
+}
+interface ResponseObject {
+    description: string;
+    headers?: {
+        [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+        [media: string]: MediaTypeObject;
+    };
+    links?: {
+        [link: string]: ReferenceObject | LinkObject;
+    };
+}
+interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+        [parameter: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+}
+interface CallbackObject {
+    [url: string]: PathItemObject;
+}
+interface SecurityRequirementObject {
+    [name: string]: string[];
+}
+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;
+    };
+}
+type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+interface HttpSecurityScheme {
+    type: "http";
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+}
+interface ApiKeySecurityScheme {
+    type: "apiKey";
+    description?: string;
+    name: string;
+    in: string;
+}
+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;
+            };
+        };
+    };
+}
+interface OpenIdSecurityScheme {
+    type: "openIdConnect";
+    description?: string;
+    openIdConnectUrl: string;
+}
+interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+export type OpenApiOptions = {
+    exclude?: boolean;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    description?: string;
+    summary?: string;
+    components?: ComponentsObject;
+    response?: any;
+    responseBody?: any;
+    requestBody?: any;
+} & any;
+export declare function OpenApi(options: OpenApiOptions): MethodDecorator & ClassDecorator & PropertyDecorator;
+export {};

package/dist/openapi.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = {}));
+function OpenApi(options) {
+    return function (target, propertyKey, descriptor) {
+        if (typeof target === "function" && !propertyKey) {
+            Reflect.defineMetadata("controller:openapi", options, target);
+        }
+        else if (descriptor) {
+            Reflect.defineMetadata("route:openapi", options, target, propertyKey);
+        }
+        else if (propertyKey) {
+            Reflect.defineMetadata("property:openapi", options, target, propertyKey);
+        }
+    };
+}

package/dist/params.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 {};

package/dist/params.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Header = exports.Body = exports.Query = exports.Param = void 0;
+const container_1 = require("./container");
+const helpers_1 = require("./helpers");
+function createParamDecorator(type) {
+    return function (key, options = {}) {
+        return function (target, propertyKey, parameterIndex) {
+            var _a;
+            const existingParams = Reflect.getMetadata(type, target, propertyKey) || [];
+            const parameterTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+            const functionSource = target[propertyKey].toString();
+            const paramNames = (_a = functionSource.match(/\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1].split(',').map((name) => name.trim());
+            const paramDataType = parameterTypes[parameterIndex];
+            existingParams.push({
+                index: parameterIndex,
+                key: key ? key : 'all',
+                name: paramNames[parameterIndex],
+                required: options.required || false,
+                validate: options.validate || true,
+                dataType: (0, helpers_1.getDataType)(paramDataType),
+                validatorClass: (0, helpers_1.isClassValidatorClass)(paramDataType),
+                type
+            });
+            switch (type) {
+                case 'route:param':
+                    Reflect.defineMetadata(container_1.PARAM_META_KEY, existingParams, target, propertyKey);
+                    break;
+                case 'route:query':
+                    Reflect.defineMetadata(container_1.QUERY_META_KEY, existingParams, target, propertyKey);
+                    break;
+                case 'route:body':
+                    Reflect.defineMetadata(container_1.REQUEST_BODY_META_KEY, existingParams, target, propertyKey);
+                    break;
+                case 'route:header':
+                    Reflect.defineMetadata(container_1.REQUEST_HEADER_META_KEY, existingParams, target, propertyKey);
+                    break;
+                default:
+                    break;
+            }
+        };
+    };
+}
+exports.Param = createParamDecorator("route:param");
+exports.Query = createParamDecorator("route:query");
+exports.Body = createParamDecorator("route:body");
+exports.Header = createParamDecorator("route:header");
+``;

package/dist/queue.js

@@ -0,0 +1 @@
+"use strict";

package/dist/repository.js

@@ -0,0 +1 @@
+"use strict";

package/dist/response.d.ts

@@ -0,0 +1,9 @@
+import 'reflect-metadata';
+export interface IHttpResponse<T extends any> {
+    message: string;
+    data: T | null;
+}
+export declare class HttpResponse {
+    static Ok<T extends {}>(obj: any, s?: any): any;
+    static NoContent(): void;
+}

package/dist/response.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponse = void 0;
+require("reflect-metadata");
+const class_transformer_1 = require("class-transformer");
+function isClassTransformerClass(target) {
+    const prototype = target.prototype;
+    const keys = Reflect.getMetadataKeys(prototype);
+    // Check for class-transformer metadata
+    return keys.some(key => key.startsWith('class_transformer:'));
+}
+function isClassTransformerType(target) {
+    return isClassTransformerClass(target);
+}
+class HttpResponse {
+    static Ok(obj, s) {
+        if (s) {
+            let pg = false;
+            if (obj.hasOwnProperty('total')) {
+                pg = true;
+            }
+            const data = (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(s, pg ? obj.data : obj, { enableImplicitConversion: true, exposeUnsetFields: false }), { strategy: 'excludeAll' });
+            if (pg) {
+                return Object.assign(Object.assign({ message: "success" }, obj), { data: data });
+            }
+            else {
+                return { message: "success", data };
+            }
+        }
+        else {
+            return { message: "success", data: obj };
+        }
+    }
+    static NoContent() { }
+}
+exports.HttpResponse = HttpResponse;

package/dist/results.d.ts

@@ -0,0 +1,20 @@
+export type OkOptions = {
+    streamable: boolean;
+};
+export declare class Results {
+    static code: number;
+    message: string;
+    static Ok<T>(data: T): Ok<T>;
+    static NoContent(): void;
+    static OkStream(): void;
+    static NotFound<T>(message: T): NotFound<T>;
+}
+export declare class Ok<T> {
+    data: T;
+    constructor(data: T);
+}
+export declare class NotFound<T> {
+    message: T;
+    constructor(message: T);
+}
+export type RouteResult<T = any> = typeof Results.Ok<T>;

package/dist/results.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFound = exports.Ok = exports.Results = void 0;
+class Results {
+    constructor() {
+        this.message = "Something going wrong";
+    }
+    static Ok(data) {
+        return new Ok(data);
+    }
+    static NoContent() {
+        this.code = 204;
+    }
+    static OkStream() { }
+    static NotFound(message) {
+        return new NotFound(message);
+    }
+}
+exports.Results = Results;
+Results.code = 500;
+class Ok {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.Ok = Ok;
+class NotFound {
+    constructor(message) {
+        this.message = message;
+    }
+}
+exports.NotFound = NotFound;

package/dist/route-methods.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { OpenApiOptions } from "./openapi";
+export type RouteMethods = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "ALL";
+/**
+ * Options for defining a route's method and metadata.
+ */
+export type RouteMethodOptions = {
+    /**
+     * HTTP method for the route (e.g., GET, POST, PUT, DELETE).
+     */
+    method?: RouteMethods;
+    /**
+     * The path or endpoint for the route (e.g., "/users/:id").
+     */
+    path?: string;
+    /**
+     * OpenAPI metadata for the route, including summary and description.
+     */
+    openapi?: OpenApiOptions;
+    /**
+     * Name of the route.
+     *
+     * @description If Swagger is enabled in the project, this will appear as a tag in the generated documentation.
+     */
+    name?: string;
+};
+export declare function createRouteDecorator(method?: RouteMethods): (pathOrOptions: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+/**
+ * @description HTTP Get method
+ * @param {string} path
+ */
+export declare function Get(path?: string): MethodDecorator;
+export declare function Get(path: string | RouteMethodOptions): MethodDecorator;
+/**
+ * @description HTTP Get method
+ * @param {string} path
+ * @param {RouteMethodOptions} options
+ */
+export declare function Get(path: string, options: RouteMethodOptions): MethodDecorator;
+export declare function Post(path?: string): MethodDecorator;
+export declare function Post(path: string | RouteMethodOptions): MethodDecorator;
+export declare function Post(path: string, options: RouteMethodOptions): MethodDecorator;
+export declare function Put(path?: string): MethodDecorator;
+export declare function Put(path: string | RouteMethodOptions): MethodDecorator;
+export declare function Put(path: string, options: RouteMethodOptions): MethodDecorator;
+export declare function Delete(path?: string): MethodDecorator;
+export declare function Delete(path: string | RouteMethodOptions): MethodDecorator;
+export declare function Delete(path: string, options: RouteMethodOptions): MethodDecorator;
+export declare const Patch: (pathOrOptions: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+export declare const Options: (pathOrOptions: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+export declare const All: (pathOrOptions: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;

package/dist/route-methods.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.All = exports.Options = exports.Patch = void 0;
+exports.createRouteDecorator = createRouteDecorator;
+exports.Get = Get;
+exports.Post = Post;
+exports.Put = Put;
+exports.Delete = Delete;
+const container_1 = require("./container");
+const schema = {
+    tags: ["hello"],
+};
+// Overloads
+// Implementation
+function createRouteDecorator(method = "GET") {
+    return function (pathOrOptions, maybeOptions) {
+        return function (target, propertyKey, descriptor) {
+            let path = "/";
+            let options = {};
+            if (typeof pathOrOptions === "string") {
+                path = pathOrOptions;
+                options = maybeOptions || {};
+            }
+            else if (typeof pathOrOptions === "object") {
+                options = pathOrOptions;
+                path = options.name || "/";
+            }
+            // Define metadata
+            Reflect.defineMetadata("route:path", path, target, propertyKey);
+            Reflect.defineMetadata("route:method", method || "GET", target, propertyKey);
+            Reflect.getMetadata(container_1.CONTROLLER_META_KEY, target.constructor);
+            Reflect.defineMetadata(container_1.ROUTE_META_KEY, Object.assign(Object.assign({}, options), { method, path, controller: target.constructor.name }), target, propertyKey);
+            if (options) {
+                Reflect.defineMetadata("route:options", options, target, propertyKey);
+            }
+        };
+    };
+}
+function Get(path, options) {
+    const parsedPath = !path && !options ? "/" : path;
+    if (options) {
+        return createRouteDecorator("GET")(parsedPath, options);
+    }
+    else {
+        return createRouteDecorator("GET")(parsedPath);
+    }
+}
+function Post(path, options) {
+    const parsedPath = !path && !options ? "/" : path;
+    if (options) {
+        return createRouteDecorator("POST")(parsedPath, options);
+    }
+    else {
+        return createRouteDecorator("POST")(parsedPath);
+    }
+}
+function Put(path, options) {
+    const parsedPath = !path && !options ? "/" : path;
+    if (options) {
+        return createRouteDecorator("PUT")(parsedPath, options);
+    }
+    else {
+        return createRouteDecorator("PUT")(parsedPath);
+    }
+}
+function Delete(path, options) {
+    const parsedPath = !path && !options ? "/" : path;
+    if (options) {
+        return createRouteDecorator("DELETE")(parsedPath, options);
+    }
+    else {
+        return createRouteDecorator("DELETE")(parsedPath);
+    }
+}
+exports.Patch = createRouteDecorator("PATCH");
+exports.Options = createRouteDecorator("OPTIONS");
+exports.All = createRouteDecorator("ALL");

package/dist/swagger-schema.d.ts

@@ -0,0 +1 @@
+export declare function generateSwaggerSchema(classType: any): any;