@bool-ts/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 BoolTS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# core

package/__test/controller.d.ts

@@ -0,0 +1,11 @@
+import type { IService } from "./interfaces";
+export declare class TestController {
+    private readonly testService;
+    constructor(testService: IService);
+    private _get;
+    private _post;
+    private _put;
+    private _patch;
+    private _delete;
+    private _options;
+}

package/__test/controller.js

@@ -0,0 +1,59 @@
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Delete, Get, Inject, Options, Patch, Post, Put } from "../src";
+import { TestService } from "./service";
+let TestController = class TestController {
+    testService;
+    constructor(testService) {
+        this.testService = testService;
+    }
+    _get(req, res) {
+        res.json({ test: "success" }).send();
+    }
+    _post(req, res) {
+        console.log("req.body", req.body);
+        res.json({ test: "success" }).send();
+    }
+    _put(req, res) {
+        res.json({ test: "success" }).send();
+    }
+    _patch(req, res) {
+        res.json({ test: "success" }).send();
+    }
+    _delete(req, res) {
+        res.json({ test: "success" }).send();
+    }
+    _options(req, res) {
+        res.json({ test: "success" }).send();
+    }
+};
+__decorate([
+    Get()
+], TestController.prototype, "_get", null);
+__decorate([
+    Post()
+], TestController.prototype, "_post", null);
+__decorate([
+    Put()
+], TestController.prototype, "_put", null);
+__decorate([
+    Patch()
+], TestController.prototype, "_patch", null);
+__decorate([
+    Delete()
+], TestController.prototype, "_delete", null);
+__decorate([
+    Options()
+], TestController.prototype, "_options", null);
+TestController = __decorate([
+    Controller("test"),
+    __param(0, Inject(TestService))
+], TestController);
+export { TestController };

package/__test/controller.ts

@@ -0,0 +1,62 @@
+import type { IService } from "./interfaces";
+
+import { Controller, Delete, Get, Inject, Options, Patch, Post, Put } from "../src";
+import { TestService } from "./service";
+import { Request, Response } from "express";
+
+
+@Controller("test")
+export class TestController {
+    constructor(
+        @Inject(TestService) private readonly testService: IService
+    ) { }
+
+    @Get()
+    private _get(
+        req: Request,
+        res: Response
+    ) {
+        res.json({ test: "success" }).send();
+    }
+
+    @Post()
+    private _post(
+        req: Request,
+        res: Response
+    ) {
+        console.log("req.body", req.body);
+        res.json({ test: "success" }).send();
+    }
+
+    @Put()
+    private _put(
+        req: Request,
+        res: Response
+    ) {
+        res.json({ test: "success" }).send();
+    }
+
+    @Patch()
+    private _patch(
+        req: Request,
+        res: Response
+    ) {
+        res.json({ test: "success" }).send();
+    }
+
+    @Delete()
+    private _delete(
+        req: Request,
+        res: Response
+    ) {
+        res.json({ test: "success" }).send();
+    }
+
+    @Options()
+    private _options(
+        req: Request,
+        res: Response
+    ) {
+        res.json({ test: "success" }).send();
+    }
+}

package/__test/index.d.ts

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

package/__test/index.js

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { BoolFactory } from "../src";
+import { TestModule } from "./module";
+const app = BoolFactory(TestModule);
+app.listen(3000, () => {
+    console.log(`Listening on port ${3000}...`);
+});

package/__test/index.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+
+import { BoolFactory } from "../src";
+import { TestModule } from "./module";
+
+
+const app = BoolFactory(TestModule);
+
+app.listen(3000, () => {
+    console.log(`Listening on port ${3000}...`);
+});

package/__test/interfaces.d.ts

@@ -0,0 +1,6 @@
+export interface IRepository {
+    exec(): void;
+}
+export interface IService {
+    exec(): void;
+}

package/__test/interfaces.ts

@@ -0,0 +1,7 @@
+export interface IRepository {
+    exec(): void;
+}
+
+export interface IService {
+    exec(): void;
+}

package/__test/module.d.ts

@@ -0,0 +1,3 @@
+export declare class TestModule {
+}
+export default TestModule;

package/__test/module.js

@@ -0,0 +1,24 @@
+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;
+};
+import { Module } from "../src";
+import { TestController } from "./controller";
+import { TestService } from "./service";
+let TestModule = class TestModule {
+};
+TestModule = __decorate([
+    Module({
+        controllers: [
+            TestController
+        ],
+        dependencies: [
+            TestService,
+            // TestRepository
+        ]
+    })
+], TestModule);
+export { TestModule };
+export default TestModule;

package/__test/module.ts

@@ -0,0 +1,17 @@
+import { Module } from "../src";
+import { TestController } from "./controller";
+import { TestRepository } from "./repository";
+import { TestService } from "./service";
+
+@Module({
+    controllers: [
+        TestController
+    ],
+    dependencies: [
+        TestService,
+        // TestRepository
+    ]
+})
+export class TestModule { }
+
+export default TestModule;

package/__test/repository.d.ts

@@ -0,0 +1,8 @@
+import type { IRepository } from "./interfaces";
+export declare class TestRepository implements IRepository {
+    /**
+     *
+     */
+    exec(): void;
+}
+export default TestRepository;

package/__test/repository.js

@@ -0,0 +1,20 @@
+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;
+};
+import { Injectable } from "../src";
+let TestRepository = class TestRepository {
+    /**
+     *
+     */
+    exec() {
+        console.log("This is test repository.");
+    }
+};
+TestRepository = __decorate([
+    Injectable()
+], TestRepository);
+export { TestRepository };
+export default TestRepository;

package/__test/repository.ts

@@ -0,0 +1,16 @@
+import type { IRepository } from "./interfaces";
+
+import { Injectable } from "../src";
+
+
+@Injectable()
+export class TestRepository implements IRepository {
+    /**
+     * 
+     */
+    exec() {
+        console.log("This is test repository.");
+    }
+}
+
+export default TestRepository;

package/__test/router.js

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

package/__test/service.d.ts

@@ -0,0 +1,9 @@
+import type { IService, IRepository } from "./interfaces";
+export declare class TestService implements IService {
+    private readonly testRepository;
+    constructor(testRepository: IRepository);
+    /**
+     *
+     */
+    exec(): void;
+}

package/__test/service.js

@@ -0,0 +1,29 @@
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "../src";
+import { TestRepository } from "./repository";
+let TestService = class TestService {
+    testRepository;
+    constructor(testRepository) {
+        this.testRepository = testRepository;
+    }
+    /**
+     *
+     */
+    exec() {
+        console.log("This is test service.", this.testRepository);
+        this.testRepository.exec();
+    }
+};
+TestService = __decorate([
+    Injectable(),
+    __param(0, Inject(TestRepository))
+], TestService);
+export { TestService };

package/__test/service.ts

@@ -0,0 +1,20 @@
+import type { IService, IRepository } from "./interfaces";
+
+import { Inject, Injectable } from "../src";
+import { TestRepository } from "./repository";
+
+
+@Injectable()
+export class TestService implements IService {
+    constructor(
+        @Inject(TestRepository) private readonly testRepository: IRepository
+    ) { }
+
+    /**
+     * 
+     */
+    exec() {
+        console.log("This is test service.", this.testRepository);
+        this.testRepository.exec();
+    }
+}

package/dist/decorators/controller.d.ts

@@ -0,0 +1,3 @@
+export declare const controllerKey = "__bool:controller__";
+export declare const Controller: (prefix: string) => <T extends Object>(target: T, context?: ClassDecoratorContext) => T;
+export default Controller;

package/dist/decorators/controller.js

@@ -0,0 +1,8 @@
+import { injectableKey } from "./injectable";
+export const controllerKey = "__bool:controller__";
+export const Controller = (prefix) => (target, context) => {
+    Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
+    Reflect.defineMetadata(injectableKey, undefined, target);
+    return target;
+};
+export default Controller;

package/dist/decorators/http.d.ts

@@ -0,0 +1,51 @@
+export interface IControllerRoute {
+    path: string;
+    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+    methodName: string;
+    descriptor: PropertyDescriptor;
+}
+export declare const controllerRoutesKey = "__bool:controller.routes__";
+/**
+ *
+ * @param path
+ * @returns
+ */
+export declare const Get: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+/**
+ *
+ * @param path
+ * @returns
+ */
+export declare const Post: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+/**
+ *
+ * @param path
+ * @returns
+ */
+export declare const Put: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+/**
+ *
+ * @param path
+ * @returns
+ */
+export declare const Patch: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+/**
+ *
+ * @param path
+ * @returns
+ */
+export declare const Delete: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+/**
+ *
+ * @param path
+ * @returns
+ */
+export declare const Options: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+declare const _default: {
+    Get: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+    Post: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+    Put: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+    Patch: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+    Delete: (path?: string) => (target: Object, methodName: string, descriptor: PropertyDescriptor) => void;
+};
+export default _default;

package/dist/decorators/http.js

@@ -0,0 +1,122 @@
+export const controllerRoutesKey = "__bool:controller.routes__";
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Get = (path = "/") => (target, methodName, descriptor) => {
+    if (typeof descriptor.value !== "function") {
+        throw Error("Get decorator only use for method.");
+    }
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+        {
+            path: !path.startsWith("/") ? `/${path}` : path,
+            httpMethod: "GET",
+            methodName: methodName,
+            descriptor: descriptor
+        }
+    ], target.constructor);
+};
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Post = (path = "/") => (target, methodName, descriptor) => {
+    if (typeof descriptor.value !== "function") {
+        throw Error("Post decorator only use for method.");
+    }
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+        {
+            path: !path.startsWith("/") ? `/${path}` : path,
+            httpMethod: "POST",
+            methodName: methodName,
+            descriptor: descriptor
+        }
+    ], target.constructor);
+};
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Put = (path = "/") => (target, methodName, descriptor) => {
+    if (typeof descriptor.value !== "function") {
+        throw Error("Put decorator only use for method.");
+    }
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+        {
+            path: !path.startsWith("/") ? `/${path}` : path,
+            httpMethod: "PUT",
+            methodName: methodName,
+            descriptor: descriptor
+        }
+    ], target.constructor);
+};
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Patch = (path = "/") => (target, methodName, descriptor) => {
+    if (typeof descriptor.value !== "function") {
+        throw Error("Patch decorator only use for method.");
+    }
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+        {
+            path: !path.startsWith("/") ? `/${path}` : path,
+            httpMethod: "PATCH",
+            methodName: methodName,
+            descriptor: descriptor
+        }
+    ], target.constructor);
+};
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Delete = (path = "/") => (target, methodName, descriptor) => {
+    if (typeof descriptor.value !== "function") {
+        throw Error("Delete decorator only use for method.");
+    }
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+        {
+            path: !path.startsWith("/") ? `/${path}` : path,
+            httpMethod: "DELETE",
+            methodName: methodName,
+            descriptor: descriptor
+        }
+    ], target.constructor);
+};
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Options = (path = "/") => (target, methodName, descriptor) => {
+    if (typeof descriptor.value !== "function") {
+        throw Error("Options decorator only use for method.");
+    }
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+        {
+            path: !path.startsWith("/") ? `/${path}` : path,
+            httpMethod: "OPTIONS",
+            methodName: methodName,
+            descriptor: descriptor
+        }
+    ], target.constructor);
+};
+export default {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete
+};

package/dist/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export { Controller, controllerKey } from "./controller";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Module, moduleKey, type TModuleOptions } from "./module";
+export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey, type IControllerRoute } from "./http";

package/dist/decorators/index.js

@@ -0,0 +1,5 @@
+export { Controller, controllerKey } from "./controller";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Module, moduleKey } from "./module";
+export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey } from "./http";

package/dist/decorators/inject.d.ts

@@ -0,0 +1,3 @@
+export declare const injectKey = "design:paramtypes";
+export declare const Inject: <T>(constructor: new (...args: any[]) => T) => (target: Object, parameterName: string | Symbol | undefined, parameterIndex: number) => void;
+export default Inject;

package/dist/decorators/inject.js

@@ -0,0 +1,9 @@
+export const injectKey = "design:paramtypes";
+export const Inject = (constructor) => {
+    return (target, parameterName, parameterIndex) => {
+        const designParameterTypes = Reflect.getMetadata(injectKey, target.constructor) || [];
+        designParameterTypes[parameterIndex] = constructor;
+        Reflect.defineMetadata(injectKey, designParameterTypes, target.constructor);
+    };
+};
+export default Inject;

package/dist/decorators/injectable.d.ts

@@ -0,0 +1,3 @@
+export declare const injectableKey = "__bool:injectable__";
+export declare const Injectable: () => <T extends Object>(target: T, context?: ClassDecoratorContext) => T;
+export default Injectable;

package/dist/decorators/injectable.js

@@ -0,0 +1,6 @@
+export const injectableKey = "__bool:injectable__";
+export const Injectable = () => (target, context) => {
+    Reflect.defineMetadata(injectableKey, undefined, target.constructor);
+    return target;
+};
+export default Injectable;

package/dist/decorators/module.d.ts

@@ -0,0 +1,7 @@
+export type TModuleOptions = Partial<{
+    controllers: Array<new (...args: any[]) => unknown>;
+    dependencies: Array<new (...args: any[]) => unknown>;
+}> | undefined;
+export declare const moduleKey = "__bool:module__";
+export declare const Module: (args?: TModuleOptions) => <T extends new (...args: any[]) => {}>(target: T, context?: ClassDecoratorContext) => T;
+export default Module;

package/dist/decorators/module.js

@@ -0,0 +1,6 @@
+export const moduleKey = "__bool:module__";
+export const Module = (args) => (target, context) => {
+    Reflect.defineMetadata(moduleKey, args, target);
+    return target;
+};
+export default Module;

package/dist/hooks/factory.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import "colors";
+/**
+ *
+ * @param target
+ */
+export declare const BoolFactory: (target: new (...args: any[]) => unknown) => import("express-serve-static-core").Express;
+export default BoolFactory;