@duplojs/http 0.1.0 → 0.2.0

package/dist/plugins/codeGenerator/routeToDataParser.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+var stepsToDataParser = require('./stepsToDataParser.cjs');
+var utils = require('@duplojs/utils');
+
+const digitDataParser = utils.DP.literal(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]).setIdentifier("Digit");
+const responseCodeDataParsers = {
+    information: utils.DP.templateLiteral([
+        "1",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    success: utils.DP.templateLiteral([
+        "2",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    redirection: utils.DP.templateLiteral([
+        "3",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    clientError: utils.DP.templateLiteral([
+        "4",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    serverError: utils.DP.templateLiteral([
+        "5",
+        digitDataParser,
+        digitDataParser,
+    ]),
+};
+const responseCodeDataParser = utils.DP.union([
+    responseCodeDataParsers.information,
+    responseCodeDataParsers.success,
+    responseCodeDataParsers.redirection,
+    responseCodeDataParsers.clientError,
+    responseCodeDataParsers.serverError,
+]).setIdentifier("ResponseCode");
+function routeToDataParser(route, params) {
+    return utils.pipe([
+        ...route.definition.preflightSteps,
+        ...route.definition.steps,
+    ], (steps) => stepsToDataParser.stepsToDataParser(steps, {
+        defaultExtractContract: params.defaultExtractContract,
+    }), utils.O.transformProperty("entrypointContract", utils.innerPipe(utils.O.entries, utils.A.select(({ element: [key, value], select, skip }) => {
+        if (utils.DP.dataParserKind.has(value)) {
+            return select(utils.O.entry(key, value));
+        }
+        if (utils.O.countKeys(value) > 0) {
+            return select(utils.O.entry(key, utils.DP.object(value)));
+        }
+        return skip();
+    }), utils.O.fromEntries)), ({ endpointContract, entrypointContract }) => utils.DP.object({
+        method: utils.DP.literal(route.definition.method),
+        path: utils.DP.literal(route.definition.paths),
+        ...entrypointContract,
+        responses: utils.DP.union([
+            utils.DP.object({
+                code: responseCodeDataParser,
+                information: utils.DP.string(),
+                body: utils.DP.unknown(),
+                fromHook: utils.DP.literal(true),
+            }),
+            utils.DP.object({
+                code: responseCodeDataParsers.serverError,
+                information: utils.DP.string(),
+                body: utils.DP.unknown(),
+            }),
+            ...endpointContract,
+        ]),
+    }));
+}
+
+exports.digitDataParser = digitDataParser;
+exports.responseCodeDataParser = responseCodeDataParser;
+exports.responseCodeDataParsers = responseCodeDataParsers;
+exports.routeToDataParser = routeToDataParser;

package/dist/plugins/codeGenerator/routeToDataParser.d.ts

@@ -0,0 +1,186 @@
+import { type Route } from "../../core/route";
+import { DP, type DString } from "@duplojs/utils";
+import { type ResponseContract } from "../../core/response";
+export interface RouteToDataParserParams {
+    readonly defaultExtractContract: ResponseContract.Contract;
+}
+export declare const digitDataParser: DP.DataParserLiteral<{
+    readonly value: readonly DString.Digit[];
+    readonly errorMessage?: string | undefined;
+    readonly identifier?: string | undefined;
+    readonly checkers: readonly [];
+}>;
+export declare const responseCodeDataParsers: {
+    information: DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["1", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>;
+    success: DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["2", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>;
+    redirection: DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["3", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>;
+    clientError: DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["4", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>;
+    serverError: DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["5", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>;
+};
+export declare const responseCodeDataParser: DP.DataParserUnion<{
+    readonly options: [DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["1", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>, DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["2", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>, DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["3", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>, DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["4", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>, DP.DataParserTemplateLiteral<{
+        readonly template: readonly ["5", DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>, DP.DataParserLiteral<{
+            readonly value: readonly DString.Digit[];
+            readonly errorMessage?: string | undefined;
+            readonly identifier?: string | undefined;
+            readonly checkers: readonly [];
+        }>];
+        readonly errorMessage?: string | undefined;
+        readonly identifier?: string | undefined;
+        readonly pattern: RegExp;
+        readonly checkers: readonly [];
+    }>];
+    readonly errorMessage?: string | undefined;
+    readonly identifier?: string | undefined;
+    readonly checkers: readonly [];
+}>;
+export declare function routeToDataParser(route: Route, params: RouteToDataParserParams): DP.DataParser;

package/dist/plugins/codeGenerator/routeToDataParser.mjs

@@ -0,0 +1,74 @@
+import { stepsToDataParser } from './stepsToDataParser.mjs';
+import { DP, pipe, O, innerPipe, A } from '@duplojs/utils';
+
+const digitDataParser = DP.literal(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]).setIdentifier("Digit");
+const responseCodeDataParsers = {
+    information: DP.templateLiteral([
+        "1",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    success: DP.templateLiteral([
+        "2",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    redirection: DP.templateLiteral([
+        "3",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    clientError: DP.templateLiteral([
+        "4",
+        digitDataParser,
+        digitDataParser,
+    ]),
+    serverError: DP.templateLiteral([
+        "5",
+        digitDataParser,
+        digitDataParser,
+    ]),
+};
+const responseCodeDataParser = DP.union([
+    responseCodeDataParsers.information,
+    responseCodeDataParsers.success,
+    responseCodeDataParsers.redirection,
+    responseCodeDataParsers.clientError,
+    responseCodeDataParsers.serverError,
+]).setIdentifier("ResponseCode");
+function routeToDataParser(route, params) {
+    return pipe([
+        ...route.definition.preflightSteps,
+        ...route.definition.steps,
+    ], (steps) => stepsToDataParser(steps, {
+        defaultExtractContract: params.defaultExtractContract,
+    }), O.transformProperty("entrypointContract", innerPipe(O.entries, A.select(({ element: [key, value], select, skip }) => {
+        if (DP.dataParserKind.has(value)) {
+            return select(O.entry(key, value));
+        }
+        if (O.countKeys(value) > 0) {
+            return select(O.entry(key, DP.object(value)));
+        }
+        return skip();
+    }), O.fromEntries)), ({ endpointContract, entrypointContract }) => DP.object({
+        method: DP.literal(route.definition.method),
+        path: DP.literal(route.definition.paths),
+        ...entrypointContract,
+        responses: DP.union([
+            DP.object({
+                code: responseCodeDataParser,
+                information: DP.string(),
+                body: DP.unknown(),
+                fromHook: DP.literal(true),
+            }),
+            DP.object({
+                code: responseCodeDataParsers.serverError,
+                information: DP.string(),
+                body: DP.unknown(),
+            }),
+            ...endpointContract,
+        ]),
+    }));
+}
+
+export { digitDataParser, responseCodeDataParser, responseCodeDataParsers, routeToDataParser };

package/dist/plugins/codeGenerator/stepsToDataParser.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+require('../../core/steps/index.cjs');
+var utils = require('@duplojs/utils');
+var process = require('../../core/steps/process.cjs');
+var extract = require('../../core/steps/extract.cjs');
+var presetChecker = require('../../core/steps/presetChecker.cjs');
+var checker = require('../../core/steps/checker.cjs');
+var cut = require('../../core/steps/cut.cjs');
+var handler = require('../../core/steps/handler.cjs');
+
+function stepsToDataParser(steps, params) {
+    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), utils.O.to({
+        entrypointContract: utils.A.map((result) => result.entrypointContract),
+        endpointContract: utils.A.flatMap((result) => result.endpointContract),
+    }));
+    const entrypointContract = utils.pipe(steps, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
+        body: {},
+        headers: {},
+        params: {},
+        query: {},
+    }), ({ element: shape, lastValue, nextWithObject }) => utils.pipe(lastValue, utils.O.entries, utils.A.map(([key, accumulatorValue]) => {
+        const currentExtractDataParser = shape[key];
+        if (utils.DP.dataParserKind.has(accumulatorValue)
+            || !currentExtractDataParser
+            || (!utils.DP.dataParserKind.has(accumulatorValue)
+                && utils.O.countKeys(accumulatorValue) > 1
+                && utils.DP.dataParserKind.has(currentExtractDataParser)
+                && !utils.DP.objectKind.has(currentExtractDataParser))) {
+            return utils.O.entry(key, accumulatorValue);
+        }
+        if (!utils.DP.dataParserKind.has(currentExtractDataParser)) {
+            return utils.O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser,
+            });
+        }
+        if (utils.DP.identifier(currentExtractDataParser, utils.DP.objectKind)) {
+            return utils.O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser.definition.shape,
+            });
+        }
+        return utils.O.entry(key, currentExtractDataParser);
+    }), utils.O.fromEntries, (object) => nextWithObject(lastValue, object))));
+    const endpointContract = utils.pipe(steps, utils.A.flatMap((step) => utils.P.match(step)
+        .when(process.processStepKind.has, () => [])
+        .when(extract.extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
+        .when(presetChecker.presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
+        .when(utils.hasSomeKinds([
+        checker.checkerStepKind,
+        cut.cutStepKind,
+        handler.handlerStepKind,
+    ]), ({ definition }) => definition.responseContract)
+        .exhaustive()), utils.A.map(({ code, information, body }) => utils.DP.object({
+        code: utils.DP.literal(code),
+        information: utils.DP.literal(information),
+        body,
+    })), utils.A.concat(processContracts.endpointContract));
+    return {
+        entrypointContract,
+        endpointContract,
+    };
+}
+
+exports.stepsToDataParser = stepsToDataParser;

package/dist/plugins/codeGenerator/stepsToDataParser.d.ts

@@ -0,0 +1,14 @@
+import { type Steps } from "../../core/steps";
+import { DP } from "@duplojs/utils";
+import { type EntrypointKey } from "./types";
+import { type ResponseContract } from "../../core/response";
+type EntrypointReduceResult = Record<EntrypointKey, DP.DataParser | Record<string, DP.DataParser>>;
+export interface StepsToDataParserParams {
+    readonly defaultExtractContract: ResponseContract.Contract;
+}
+export interface StepsToDataParserResult {
+    entrypointContract: EntrypointReduceResult;
+    endpointContract: DP.DataParser[];
+}
+export declare function stepsToDataParser(steps: readonly Steps[], params: StepsToDataParserParams): StepsToDataParserResult;
+export {};

package/dist/plugins/codeGenerator/stepsToDataParser.mjs

@@ -0,0 +1,64 @@
+import '../../core/steps/index.mjs';
+import { pipe, A, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { processStepKind } from '../../core/steps/process.mjs';
+import { extractStepKind } from '../../core/steps/extract.mjs';
+import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
+import { checkerStepKind } from '../../core/steps/checker.mjs';
+import { cutStepKind } from '../../core/steps/cut.mjs';
+import { handlerStepKind } from '../../core/steps/handler.mjs';
+
+function stepsToDataParser(steps, params) {
+    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), O.to({
+        entrypointContract: A.map((result) => result.entrypointContract),
+        endpointContract: A.flatMap((result) => result.endpointContract),
+    }));
+    const entrypointContract = pipe(steps, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
+        body: {},
+        headers: {},
+        params: {},
+        query: {},
+    }), ({ element: shape, lastValue, nextWithObject }) => pipe(lastValue, O.entries, A.map(([key, accumulatorValue]) => {
+        const currentExtractDataParser = shape[key];
+        if (DP.dataParserKind.has(accumulatorValue)
+            || !currentExtractDataParser
+            || (!DP.dataParserKind.has(accumulatorValue)
+                && O.countKeys(accumulatorValue) > 1
+                && DP.dataParserKind.has(currentExtractDataParser)
+                && !DP.objectKind.has(currentExtractDataParser))) {
+            return O.entry(key, accumulatorValue);
+        }
+        if (!DP.dataParserKind.has(currentExtractDataParser)) {
+            return O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser,
+            });
+        }
+        if (DP.identifier(currentExtractDataParser, DP.objectKind)) {
+            return O.entry(key, {
+                ...accumulatorValue,
+                ...currentExtractDataParser.definition.shape,
+            });
+        }
+        return O.entry(key, currentExtractDataParser);
+    }), O.fromEntries, (object) => nextWithObject(lastValue, object))));
+    const endpointContract = pipe(steps, A.flatMap((step) => P.match(step)
+        .when(processStepKind.has, () => [])
+        .when(extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
+        .when(presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
+        .when(hasSomeKinds([
+        checkerStepKind,
+        cutStepKind,
+        handlerStepKind,
+    ]), ({ definition }) => definition.responseContract)
+        .exhaustive()), A.map(({ code, information, body }) => DP.object({
+        code: DP.literal(code),
+        information: DP.literal(information),
+        body,
+    })), A.concat(processContracts.endpointContract));
+    return {
+        entrypointContract,
+        endpointContract,
+    };
+}
+
+export { stepsToDataParser };

package/dist/plugins/codeGenerator/types/entrypointKey.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/plugins/codeGenerator/types/entrypointKey.d.ts

@@ -0,0 +1 @@
+export type EntrypointKey = "query" | "body" | "params" | "headers";

package/dist/plugins/codeGenerator/types/entrypointKey.mjs

@@ -0,0 +1 @@
+

package/dist/plugins/codeGenerator/types/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./entrypointKey.cjs');
+

package/dist/plugins/codeGenerator/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./entrypointKey";

package/dist/plugins/codeGenerator/types/index.mjs

@@ -0,0 +1 @@
+import './entrypointKey.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -14,7 +14,7 @@
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json",
+    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json",
     "test:lint": "eslint",
     "test:lint:fix": "eslint --fix",
     "prepare": "husky"
@@ -40,6 +40,11 @@
       "import": "./dist/interfaces/deno/index.mjs",
       "require": "./dist/interfaces/deno/index.cjs",
       "types": "./dist/interfaces/deno/index.d.ts"
+    },
+    "./codeGenerator": {
+      "import": "./dist/plugins/codeGenerator/index.mjs",
+      "require": "./dist/plugins/codeGenerator/index.cjs",
+      "types": "./dist/plugins/codeGenerator/index.d.ts"
     }
   },
   "files": [
@@ -47,7 +52,8 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@duplojs/utils": ">=1.1.16 <2.0.0"
+    "@duplojs/data-parser-tools": ">=0.2.2 <1.0.0",
+    "@duplojs/utils": ">=1.3.32 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",