nestia 3.1.0 → 3.1.1-dev.20221016

package/demo/generic/src/api/structures/IAttachmentFile.ts

@@ -0,0 +1,21 @@
+/**
+ * Attachemd (physical) file info.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export interface IAttachmentFile {
+    /**
+     * Name of the file.
+     */
+    name: string;
+
+    /**
+     * Extension of the file, but ommitable.
+     */
+    extension: string | null;
+
+    /**
+     * Full URL path of the file.
+     */
+    url: string;
+}

package/demo/generic/src/api/structures/ISaleArticle.ts

@@ -0,0 +1,79 @@
+import { IAttachmentFile } from "./IAttachmentFile";
+
+/**
+ * Article about a sale.
+ *
+ * The `ISaleArticle` is a super type interface. Many sub-type articles would be
+ * designed by extending this super type interface `ISaleArticle`.
+ *
+ * @template Content Content type.
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export interface ISaleArticle<Content extends ISaleArticle.IContent> {
+    /**
+     * Primary Key.
+     */
+    id: number;
+
+    /**
+     * Hit count.
+     *
+     * How many consumers had read.
+     */
+    hit: number;
+
+    /**
+     * List of contents.
+     *
+     * When the article writer tries to modify content, it would not modify the article
+     * content but would be accumulated. Therefore, all of the people can read how
+     * the content has been changed.
+     */
+    contents: Content[];
+
+    /**
+     * Creation time.
+     */
+    created_at: string;
+}
+export namespace ISaleArticle {
+    /**
+     * Content info.
+     */
+    export interface IContent extends IStore {
+        /**
+         * Primary Key
+         */
+        id: string;
+
+        /**
+         * Creation time.
+         */
+        created_at: string;
+    }
+
+    /**
+     * Store info.
+     */
+    export interface IStore {
+        /**
+         * Title of the content.
+         */
+        title: string;
+
+        /**
+         * Body of the content.
+         */
+        body: string;
+
+        /**
+         * Extension, content type (format).
+         */
+        extension: "html" | "md" | "txt";
+
+        /**
+         * Attached files.
+         */
+        files: IAttachmentFile[];
+    }
+}

package/demo/generic/src/api/structures/ISaleInquiry.ts

@@ -0,0 +1,34 @@
+import { ISaleArticle } from "./ISaleArticle";
+import { ISaleInquiryAnswer } from "./ISaleInquiryAnswer";
+
+/**
+ * Inquiry article.
+ *
+ * Sub-type of article and super-type of question and answer.
+ *
+ * @template Content Content type
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export interface ISaleInquiry<Content extends ISaleInquiry.IContent>
+    extends ISaleArticle<Content> {
+    /**
+     * Name of the writer.
+     */
+    writer: string;
+
+    /**
+     * Formal answer from the seller.
+     */
+    answer: ISaleInquiryAnswer | null;
+}
+export namespace ISaleInquiry {
+    /**
+     * Content type of the inquiry article.
+     */
+    export type IContent = ISaleArticle.IContent;
+
+    /**
+     * Store info of the inquiry article.
+     */
+    export type IStore = ISaleArticle.IStore;
+}

package/demo/generic/src/api/structures/ISaleInquiryAnswer.ts

@@ -0,0 +1,23 @@
+import { ISaleArticle } from "./ISaleArticle";
+
+/**
+ * Formal answer from the seller.
+ *
+ * When a consumer writes an inquiry about a sale, the seller can write a formal
+ * answer article. This `ISaleInquiryAnswer` has been designed to represent such
+ * formal answer article from the seller.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type ISaleInquiryAnswer = ISaleArticle<ISaleInquiryAnswer.IContent>;
+export namespace ISaleInquiryAnswer {
+    /**
+     * Content type of the answer.
+     */
+    export type IContent = ISaleArticle.IContent;
+
+    /**
+     * Store info of the answer.
+     */
+    export type IStore = ISaleArticle.IContent;
+}

package/demo/generic/src/api/structures/ISaleQuestion.ts

@@ -0,0 +1,22 @@
+import { ISaleInquiry } from "./ISaleInquiry";
+
+/**
+ * Question article.
+ *
+ * The `ISaleQuestion` is a type of question article wrriten by a consumer
+ * who has something to ask about the sale.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type ISaleQuestion = ISaleInquiry<ISaleQuestion.IContent>;
+export namespace ISaleQuestion {
+    /**
+     * Content info of the question.
+     */
+    export type IContent = ISaleInquiry.IContent;
+
+    /**
+     * Store info of the question.
+     */
+    export type IStore = ISaleInquiry.IStore;
+}

package/demo/generic/src/api/structures/ISaleReview.ts

@@ -0,0 +1,32 @@
+import { ISaleInquiry } from "./ISaleInquiry";
+
+/**
+ * Review article.
+ *
+ * The `ISaleReview` is a type of review article written by a consumer who've bought
+ * the sale good with the estimation score.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type ISaleReview = ISaleInquiry<ISaleReview.IContent>;
+export namespace ISaleReview {
+    /**
+     * Content info of the review.
+     */
+    export interface IContent extends ISaleInquiry.IContent {
+        /**
+         * Estimation score.
+         */
+        score: number;
+    }
+
+    /**
+     * Store info of the review.
+     */
+    export interface IStore extends ISaleInquiry.IStore {
+        /**
+         * Estimation score.
+         */
+        score: number;
+    }
+}

package/demo/generic/src/controllers/ConsumerSaleQuestionsController.ts

@@ -0,0 +1,33 @@
+import TSON from "typescript-json";
+import * as nest from "@nestjs/common";
+
+import { ISaleQuestion } from "@api/structures/ISaleQuestion";
+
+import { SaleInquiriesController } from "./SaleInquiriesController";
+
+@nest.Controller("consumers/:section/sales/:saleId/questions")
+export class ConsumerSaleQuestionsController extends SaleInquiriesController<
+    ISaleQuestion.IContent,
+    ISaleQuestion.IStore,
+    ISaleQuestion
+>({
+    assert: (input) => TSON.assertType(input),
+    stringify: (input) => TSON.stringify(input),
+    convert: (input) => ({
+        id: 0,
+        hit: 0,
+        writer: "someone",
+        answer: null,
+        created_at: new Date().toString(),
+        contents: [
+            {
+                id: "some-content-id",
+                title: input.title,
+                body: input.body,
+                extension: input.extension,
+                files: input.files,
+                created_at: new Date().toString(),
+            },
+        ],
+    }),
+}) {}

package/demo/generic/src/controllers/ConsumerSaleReviewsController.ts

@@ -0,0 +1,34 @@
+import * as nest from "@nestjs/common";
+
+import { ISaleReview } from "@api/structures/ISaleReview";
+
+import { SaleInquiriesController } from "./SaleInquiriesController";
+import TSON from "typescript-json";
+
+@nest.Controller("consumers/:section/sales/:saleId/reviews")
+export class ConsumerSaleReviewsController extends SaleInquiriesController<
+    ISaleReview.IContent,
+    ISaleReview.IStore,
+    ISaleReview
+>({
+    assert: (input) => TSON.assertType(input),
+    stringify: (input) => TSON.stringify(input),
+    convert: (input) => ({
+        id: 0,
+        hit: 0,
+        writer: "someone",
+        answer: null,
+        created_at: new Date().toString(),
+        contents: [
+            {
+                id: "some-content-id",
+                title: input.title,
+                body: input.body,
+                extension: input.extension,
+                files: input.files,
+                created_at: new Date().toString(),
+                score: 100,
+            },
+        ],
+    }),
+}) {}

package/demo/generic/src/controllers/SaleInquiriesController.ts

@@ -0,0 +1,87 @@
+import * as express from "express";
+import * as nest from "@nestjs/common";
+import helper from "nestia-helper";
+
+import { ISaleInquiry } from "@api/structures/ISaleInquiry";
+
+export function SaleInquiriesController<
+    Content extends ISaleInquiry.IContent,
+    Store extends ISaleInquiry.IStore,
+    Json extends ISaleInquiry<Content>,
+>(trait: SaleInquiriesController.ITrait<Content, Store, Json>) {
+    abstract class SaleInquiriesController {
+        /**
+         * Store a new inquiry.
+         *
+         * Write a new article inquirying about a sale.
+         *
+         * @param request Instance of the Express.Request
+         * @param section Code of the target section
+         * @param saleId ID of the target sale
+         * @param input Content to archive
+         * @return Newly archived inquiry
+         *
+         * @throw 400 bad request error when type of the input data is not valid
+         * @throw 401 unauthorized error when you've not logged in yet
+         */
+        @helper.TypedRoute.Post(trait.stringify)
+        public async store(
+            @nest.Request() request: express.Request,
+            @helper.TypedParam("section", "string") section: string,
+            @helper.TypedParam("saleId", "string") saleId: string,
+            @helper.TypedBody(trait.assert) input: Store,
+        ): Promise<Json> {
+            request;
+            section;
+            saleId;
+
+            return trait.convert(input);
+        }
+
+        /**
+         * Update an inquiry.
+         *
+         * Update ordinary inquiry article. However, it would not modify the content reocrd
+         * {@link ISaleInquiry.IContent}, but be accumulated into the {@link ISaleInquiry.contents}.
+         * Therefore, all of the poeple can read how the content has been changed.
+         *
+         * @param request Instance of the Express.Request
+         * @param section Code of the target section
+         * @param saleId ID of the target sale
+         * @param id ID of the target article to be updated
+         * @param input New content to be overwritten
+         * @return The newly created content record
+         *
+         * @throw 400 bad request error when type of the input data is not valid
+         * @throw 401 unauthorized error when you've not logged in yet
+         * @throw 403 forbidden error when the article is not yours
+         */
+        @helper.TypedRoute.Put(":id", trait.stringify)
+        public async update(
+            @nest.Request() request: express.Request,
+            @helper.TypedParam("section", "string") section: string,
+            @helper.TypedParam("saleId", "string") saleId: string,
+            @helper.TypedParam("id", "number") id: number,
+            @helper.TypedBody(trait.assert) input: Store,
+        ): Promise<Json> {
+            request;
+            section;
+            saleId;
+            id;
+
+            return trait.convert(input);
+        }
+    }
+    return SaleInquiriesController;
+}
+export namespace SaleInquiriesController {
+    export interface ITrait<
+        Content extends ISaleInquiry.IContent,
+        Store extends ISaleInquiry.IStore,
+        Json extends ISaleInquiry<Content>,
+    > {
+        stringify(json: Json): string;
+        assert(input: Store): Store;
+        convert(input: Store): Json;
+    }
+}

package/demo/generic/src/test/features/test_question_store.ts

@@ -0,0 +1,21 @@
+import api from "@api";
+import { ISaleQuestion } from "@api/structures/ISaleQuestion";
+import TSON from "typescript-json";
+
+export async function test_question_store(
+    connection: api.IConnection,
+): Promise<void> {
+    const question: ISaleQuestion =
+        await api.functional.consumers.sales.questions.store(
+            connection,
+            "general",
+            "some-sale-id",
+            {
+                title: "some-title",
+                body: "some-body-content",
+                files: [],
+                extension: "html",
+            },
+        );
+    TSON.assertType(question);
+}

package/demo/generic/src/test/features/test_question_update.ts

@@ -0,0 +1,42 @@
+import api from "@api";
+import { ISaleQuestion } from "@api/structures/ISaleQuestion";
+import TSON from "typescript-json";
+
+export async function test_question_update(
+    connection: api.IConnection,
+): Promise<void> {
+    const question: ISaleQuestion =
+        await api.functional.consumers.sales.questions.store(
+            connection,
+            "general",
+            "some-sale-id",
+            {
+                title: "some-title",
+                body: "some-body-content",
+                files: [],
+                extension: "html",
+            },
+        );
+    TSON.assertType(question);
+
+    const updated: ISaleQuestion =
+        await api.functional.consumers.sales.questions.update(
+            connection,
+            "general",
+            "some-sale-id",
+            question.id,
+            {
+                title: "new-title",
+                body: "new-content-body",
+                files: [
+                    {
+                        name: "typescript-json",
+                        extension: "lnk",
+                        url: "https://github.com/samchon/typescript-json",
+                    },
+                ],
+                extension: "html",
+            },
+        );
+    TSON.assertType(updated);
+}

package/demo/generic/src/test/features/test_review_store.ts

@@ -0,0 +1,22 @@
+import api from "@api";
+import { ISaleReview } from "@api/structures/ISaleReview";
+import TSON from "typescript-json";
+
+export async function test_review_store(
+    connection: api.IConnection,
+): Promise<void> {
+    const question: ISaleReview =
+        await api.functional.consumers.sales.reviews.store(
+            connection,
+            "general",
+            "some-sale-id",
+            {
+                title: "some-title",
+                body: "some-body-content",
+                files: [],
+                extension: "html",
+                score: 100,
+            },
+        );
+    TSON.assertType(question);
+}

package/demo/generic/src/test/features/test_review_update.ts

@@ -0,0 +1,44 @@
+import api from "@api";
+import { ISaleReview } from "@api/structures/ISaleReview";
+import TSON from "typescript-json";
+
+export async function test_review_update(
+    connection: api.IConnection,
+): Promise<void> {
+    const question: ISaleReview =
+        await api.functional.consumers.sales.reviews.store(
+            connection,
+            "general",
+            "some-sale-id",
+            {
+                title: "some-title",
+                body: "some-body-content",
+                files: [],
+                extension: "html",
+                score: 100,
+            },
+        );
+    TSON.assertType(question);
+
+    const updated: ISaleReview =
+        await api.functional.consumers.sales.reviews.update(
+            connection,
+            "general",
+            "some-sale-id",
+            question.id,
+            {
+                title: "new-title",
+                body: "new-content-body",
+                files: [
+                    {
+                        name: "typescript-json",
+                        extension: "lnk",
+                        url: "https://github.com/samchon/typescript-json",
+                    },
+                ],
+                extension: "html",
+                score: 90,
+            },
+        );
+    TSON.assertType(updated);
+}

package/demo/generic/src/test/index.ts

@@ -0,0 +1,24 @@
+import api from "../api";
+import { Backend } from "../Backend";
+import { Configuration } from "../Configuration";
+import { DynamicImportIterator } from "./internal/DynamicImportIterator";
+
+async function main(): Promise<void> {
+    const server: Backend = new Backend();
+    await server.open();
+
+    const connection: api.IConnection = {
+        host: `http://127.0.0.1:${Configuration.PORT}`,
+        encryption: Configuration.ENCRYPTION_PASSWORD,
+    };
+    await DynamicImportIterator.main(__dirname, {
+        prefix: "test",
+        parameters: () => [connection],
+    });
+
+    await server.close();
+}
+main().catch((exp) => {
+    console.log(exp);
+    process.exit(-1);
+});

package/demo/generic/src/test/internal/DynamicImportIterator.ts

@@ -0,0 +1,109 @@
+const EXTENSION = __filename.substr(-2);
+
+import cli from "cli";
+import fs from "fs";
+import { IPointer } from "tstl/functional/IPointer";
+
+import { StopWatch } from "./StopWatch";
+
+interface ICommand {
+    include?: string;
+    exclude?: string;
+}
+
+export namespace DynamicImportIterator {
+    export type Closure<Arguments extends any[]> = (
+        ...args: Arguments
+    ) => Promise<any>;
+    type Module<Arguments extends any[]> = {
+        [key: string]: Closure<Arguments>;
+    };
+
+    export interface IOptions<Parameters extends any[]> {
+        prefix: string;
+        parameters: () => Parameters;
+        wrapper?: (name: string, output: any) => Promise<any>;
+        counter?: IPointer<number>;
+        showElapsedTime?: boolean;
+    }
+
+    export async function main<Arguments extends any[]>(
+        path: string,
+        options: IOptions<Arguments>,
+    ): Promise<void> {
+        const command: ICommand = cli.parse();
+        await iterate(options, command, path);
+    }
+
+    export async function force<Arguments extends any[]>(
+        path: string,
+        options: IOptions<Arguments>,
+    ): Promise<Error[]> {
+        const command: ICommand = cli.parse();
+        const exceptions: Error[] = [];
+
+        await iterate(options, command, path, exceptions);
+        return exceptions;
+    }
+
+    async function iterate<Arguments extends any[]>(
+        options: IOptions<Arguments>,
+        command: ICommand,
+        path: string,
+        exceptions?: Error[],
+    ): Promise<void> {
+        const directory: string[] = await fs.promises.readdir(path);
+        for (const file of directory) {
+            const current: string = `${path}/${file}`;
+            const stats: fs.Stats = await fs.promises.lstat(current);
+
+            if (stats.isDirectory() === true) {
+                await iterate(options, command, current, exceptions);
+                continue;
+            } else if (file.substr(-3) !== `.${EXTENSION}`) continue;
+
+            const external: Module<Arguments> = await import(current);
+            await execute(options, command, external, exceptions);
+        }
+    }
+
+    async function execute<Arguments extends any[]>(
+        options: IOptions<Arguments>,
+        command: ICommand,
+        external: Module<Arguments>,
+        exceptions?: Error[],
+    ): Promise<void> {
+        for (const key in external) {
+            if (command.exclude && key.indexOf(command.exclude) !== -1)
+                continue;
+            else if (command.include && key.indexOf(command.include) === -1)
+                continue;
+            else if (key.substr(0, options.prefix.length) !== options.prefix)
+                continue;
+            else if (external[key] instanceof Function) {
+                const closure: Closure<Arguments> = external[key];
+                const func = async () => {
+                    const output = await closure(...options.parameters());
+                    if (options.wrapper) await options.wrapper(key, output);
+                };
+
+                try {
+                    if (options.counter) ++options.counter.value;
+                    if (options.showElapsedTime === false) {
+                        await func();
+                        console.log(`  - ${key}`);
+                    } else {
+                        const time: number = await StopWatch.measure(func);
+                        console.log(`  - ${key}: ${time.toLocaleString()} ms`);
+                    }
+                } catch (exp) {
+                    if (!(exp instanceof Error)) return;
+
+                    console.log(`  - ${key} -> ${exp.name}`);
+                    if (exceptions !== undefined) exceptions.push(exp);
+                    else throw exp;
+                }
+            }
+        }
+    }
+}

package/demo/generic/src/test/internal/StopWatch.ts

@@ -0,0 +1,15 @@
+export namespace StopWatch {
+    export type Task = () => Promise<void>;
+
+    export async function measure(task: Task): Promise<number> {
+        const time: number = Date.now();
+        await task();
+        return Date.now() - time;
+    }
+
+    export async function trace(title: string, task: Task): Promise<void> {
+        process.stdout.write(title);
+        const time: number = await measure(task);
+        console.log(`: ${time.toLocaleString()} ms`);
+    }
+}