feat(06): dataParserToDataParser. Well what ??? 🤯

.vscode/settings.json

@@ -20,4 +20,9 @@
 	},
 
 	"js/ts.tsdk.path": "node_modules/typescript/lib",
+	"js/ts.format.enabled": false,
+	"js/ts.tsdk.promptToUseWorkspaceVersion": true,
+	"cSpell.words": [
+		"SDPE"
+	],
 }

eslint.config.js

@@ -11,7 +11,7 @@ export default [
 			},
 		},
 		files: ["**/*.test.ts", "**/*.bench.ts", "test/**/*.ts"],
-		ignores: ["**/*.d.ts"]
+		ignores: ["**/*.d.ts", "**/*.gen.ts"]
 	},
 	{
 		...duplojsEslintOpen,
@@ -23,7 +23,7 @@ export default [
 			},
 		},
 		files: ["**/*.ts"],
-		ignores: ["**/*.test.ts", "**/*.bench.ts", "test/**/*.ts", "**/*.d.ts"],
+		ignores: ["**/*.test.ts", "**/*.bench.ts", "test/**/*.ts", "**/*.d.ts", "**/*.gen.ts"],
 	},
 	{
 		ignores: ["coverage", "dist"]

integration/toDataParser/__snapshots__/basic.gen.ts

@@ -0,0 +1,38 @@
+import * as DP from "@duplojs/utils/dataParser";
+
+export const userProfileParser = DP.object({
+    id: DP.templateLiteral(["user-", DP.number(), "-db1"]),
+    name: DP.string({ checkers: [DP.checkerStringMin(2)] }),
+    email: DP.string({ checkers: [DP.checkerEmail()] }),
+    role: DP.literal(["admin", "editor", "viewer"]),
+    age: DP.optional(DP.number({
+        coerce: true,
+        checkers: [
+            DP.checkerNumberMin(0),
+            DP.checkerNumberMax(80)
+        ]
+    })),
+    contact: DP.union([
+        DP.object({
+            phone: DP.string({ checkers: [DP.checkerRegex(/^[+\d][\d\s-]{5,}$/)] })
+        }),
+        DP.object({
+            email: DP.string({ checkers: [DP.checkerEmail()] })
+        })
+    ]),
+    address: DP.object({
+        street: DP.string(),
+        city: DP.string(),
+        zip: DP.string({ checkers: [DP.checkerRegex(/^\d{5}$/)] }),
+        country: DP.literal(["FR"])
+    }),
+    roles: DP.array(DP.literal(["admin", "editor", "viewer"]), { checkers: [DP.checkerArrayMin(1)] }),
+    preferences: DP.nullable(DP.object({
+        theme: DP.literal(["light", "dark"]),
+        newsletter: DP.boolean()
+    })),
+    metadata: DP.record(DP.string(), DP.string()),
+    location: DP.tuple([DP.number(), DP.number()], { rest: DP.number() }),
+    createdAt: DP.date({ coerce: true }),
+    startAt: DP.time()
+});

integration/toDataParser/__snapshots__/recursive.gen.ts

@@ -0,0 +1,43 @@
+import * as DP from "@duplojs/utils/dataParser";
+
+export type RecursiveType0 = {
+    name: string;
+    children: RecursiveType0[];
+    comment: {
+        id: string;
+        replies: RecursiveType1[];
+    };
+    meta: [
+        string,
+        RecursiveType2[]
+    ];
+};
+
+export type RecursiveType1 = {
+    id: string;
+    replies: RecursiveType1[];
+};
+
+export type RecursiveType2 = [
+    string,
+    RecursiveType2[]
+];
+
+export type RecursiveNode = RecursiveType0;
+
+export const recursiveDataParser1: DP.DataParser<RecursiveType1> = DP.object({
+    id: DP.string(),
+    replies: DP.array(DP.lazy(() => recursiveDataParser1))
+});
+
+export const recursiveDataParser2: DP.DataParser<RecursiveType2> = DP.tuple([DP.string(), DP.array(DP.lazy(() => recursiveDataParser2))]);
+
+export const recursiveNodeDataParser: DP.DataParser<RecursiveNode> = DP.object({
+    name: DP.string(),
+    children: DP.array(DP.lazy(() => recursiveNodeDataParser)),
+    comment: DP.object({
+        id: DP.string(),
+        replies: DP.array(DP.lazy(() => recursiveDataParser1))
+    }),
+    meta: DP.tuple([DP.string(), DP.array(DP.lazy(() => recursiveDataParser2))])
+});

integration/toDataParser/__snapshots__/withConstName.gen.ts

@@ -0,0 +1,10 @@
+import * as DP from "@duplojs/utils/dataParser";
+
+export const userRoleDataParser = DP.literal(["admin", "editor", "viewer"]);
+
+export const userDataParser = DP.object({
+    id: DP.templateLiteral(["user-", DP.number(), "-db1"]),
+    name: DP.string({ checkers: [DP.checkerStringMin(2)] }),
+    email: DP.string({ checkers: [DP.checkerEmail()] }),
+    role: userRoleDataParser
+});

integration/toDataParser/index.test.ts

@@ -0,0 +1,140 @@
+import { asserts, DPE, E, Path, S, unwrap } from "@duplojs/utils";
+import { SF } from "@duplojs/server-utils";
+import { defaultCheckerTransformers, defaultTransformers, render } from "@duplojs/data-parser-tools/toDataParser";
+import { defaultTransformers as tsDefaultTransformers } from "@duplojs/data-parser-tools/toTypescript";
+
+async function typedSnapshot(value: string, filePath: string) {
+	const absoluteFilePath = Path.resolveRelative([import.meta.dirname, filePath]);
+
+	const exist = await SF.exists(absoluteFilePath);
+
+	if (E.isLeft(exist)) {
+		const writeTextFileResult = await SF.writeTextFile(absoluteFilePath, value);
+		asserts(writeTextFileResult, E.isRight);
+	}
+
+	const expected = await E.rightAsyncPipe(
+		absoluteFilePath,
+		SF.readTextFile,
+		S.trim,
+	);
+
+	asserts(expected, E.isRight);
+
+	expect(value).toBe(unwrap(expected));
+}
+
+describe("integration", () => {
+	it("basic", async() => {
+		const userSchema = DPE.object({
+			id: DPE.templateLiteral(["user-", DPE.number(), "-db1"]),
+			name: DPE.string().min(2),
+			email: DPE.email(),
+			role: DPE.literal(["admin", "editor", "viewer"]),
+			age: DPE
+				.coerce
+				.number()
+				.min(0)
+				.max(80)
+				.optional(),
+			contact: DPE.union([
+				DPE.object({
+					phone: DPE.string().regex(/^[+\d][\d\s-]{5,}$/),
+				}),
+				DPE.object({
+					email: DPE.email(),
+				}),
+			]),
+			address: DPE.object({
+				street: DPE.string(),
+				city: DPE.string(),
+				zip: DPE.string().regex(/^\d{5}$/),
+				country: DPE.literal("FR"),
+			}),
+			roles: DPE.literal(["admin", "editor", "viewer"]).array().min(1),
+			preferences: DPE.object({
+				theme: DPE.literal(["light", "dark"]),
+				newsletter: DPE.boolean(),
+			}).nullable(),
+			metadata: DPE.record(DPE.string(), DPE.string()),
+			location: DPE.tuple([DPE.number(), DPE.number()], { rest: DPE.number() }),
+			createdAt: DPE.date({ coerce: true }),
+			startAt: DPE.time(),
+		}).addConstName("userProfileParser");
+
+		const result = render(
+			userSchema,
+			{
+				constName: "userProfileParser",
+				dataParserTransformers: defaultTransformers,
+				checkerTransformers: defaultCheckerTransformers,
+				toTypescript: {
+					identifier: "UserProfile",
+					transformers: tsDefaultTransformers,
+				},
+			},
+		);
+
+		await typedSnapshot(result, "__snapshots__/basic.gen.ts");
+	});
+
+	it("recursive", async() => {
+		const commentSchema: DPE.DataParser<unknown> = DPE.object({
+			id: DPE.string(),
+			replies: DPE.lazy(() => commentSchema).array(),
+		});
+
+		const metaSchema: DPE.DataParser<unknown> = DPE.tuple([
+			DPE.string(),
+			DPE.lazy(() => metaSchema).array(),
+		]);
+
+		const nodeSchema: DPE.DataParser<unknown> = DPE.object({
+			name: DPE.string(),
+			children: DPE.lazy(() => nodeSchema).array(),
+			comment: commentSchema,
+			meta: metaSchema,
+		}).addConstName("recursiveNodeDataParser");
+
+		const result = render(
+			nodeSchema,
+			{
+				constName: "recursiveNodeDataParser",
+				dataParserTransformers: defaultTransformers,
+				checkerTransformers: defaultCheckerTransformers,
+				toTypescript: {
+					identifier: "RecursiveNode",
+					transformers: tsDefaultTransformers,
+				},
+			},
+		);
+
+		await typedSnapshot(result, "__snapshots__/recursive.gen.ts");
+	});
+
+	it("divide with constName", async() => {
+		const roleDataParser = DPE.literal(["admin", "editor", "viewer"]).addConstName("userRoleDataParser");
+
+		const userDataParser = DPE.object({
+			id: DPE.templateLiteral(["user-", DPE.number(), "-db1"]),
+			name: DPE.string().min(2),
+			email: DPE.email(),
+			role: roleDataParser,
+		}).addConstName("userDataParser");
+
+		const result = render(
+			userDataParser,
+			{
+				constName: "userDataParser",
+				dataParserTransformers: defaultTransformers,
+				checkerTransformers: defaultCheckerTransformers,
+				toTypescript: {
+					identifier: "UserProfile",
+					transformers: tsDefaultTransformers,
+				},
+			},
+		);
+
+		await typedSnapshot(result, "__snapshots__/withConstName.gen.ts");
+	});
+});

package.json

@@ -45,6 +45,11 @@
       "import": "./dist/toJsonSchema/index.mjs",
       "require": "./dist/toJsonSchema/index.cjs",
       "types": "./dist/toJsonSchema/index.d.ts"
+    },
+    "./toDataParser": {
+      "import": "./dist/toDataParser/index.mjs",
+      "require": "./dist/toDataParser/index.cjs",
+      "types": "./dist/toDataParser/index.d.ts"
     }
   },
   "files": [

scripts/index.ts

@@ -1,4 +1,5 @@
 export * as DataParserToTypescript from "./toTypescript";
 export * as DataParserToJsonSchema from "./toJsonSchema";
+export * as DataParserToDataParser from "./toDataParser";
 
 export * from "./utils";

scripts/toDataParser/checkerTransformer/create.ts

@@ -0,0 +1,70 @@
+import type { CallExpression, ObjectLiteralExpression, PropertyAssignment } from "typescript";
+import { type DP, E } from "@duplojs/utils";
+
+export type CheckerTransformerSuccessEither = E.Right<"buildSuccess", CallExpression>;
+
+export type CheckerTransformerCheckerNotSupportedEither = E.Left<"checkerNotSupport", DP.DataParserChecker>;
+
+export type CheckerTransformerBuildErrorEither = E.Left<"buildCheckerError", DP.DataParserChecker>;
+
+export type CheckerTransformerEither =
+	| CheckerTransformerSuccessEither
+	| CheckerTransformerCheckerNotSupportedEither
+	| CheckerTransformerBuildErrorEither;
+
+export interface CheckerTransformerParams {
+	success(
+		result: CallExpression,
+	): CheckerTransformerSuccessEither;
+	buildError(): CheckerTransformerBuildErrorEither;
+	getDefinition(
+		customProperties?: readonly PropertyAssignment[]
+	): readonly [ObjectLiteralExpression] | readonly [];
+}
+
+/**
+ * @deprecated
+ */
+export type DataParserCheckers = (
+	| DP.DataParserChecker
+	| DP.DataParserCheckerArrayMax
+	| DP.DataParserCheckerArrayMin
+	| DP.DataParserCheckerBigIntMax
+	| DP.DataParserCheckerBigIntMin
+	| DP.DataParserCheckerNumberMax
+	| DP.DataParserCheckerNumberMin
+	| DP.DataParserCheckerInt
+	| DP.DataParserCheckerStringMax
+	| DP.DataParserCheckerStringMin
+	| DP.DataParserCheckerEmail
+	| DP.DataParserCheckerRegex
+	| DP.DataParserCheckerUrl
+	| DP.DataParserCheckerUuid
+	| DP.DataParserCheckerRefine
+	| DP.DataParserCheckerTimeMin
+	| DP.DataParserCheckerTimeMax
+);
+
+export type CheckerTransformerBuildFunction<
+	GenericChecker extends DataParserCheckers = DataParserCheckers,
+> = (
+	checker: GenericChecker,
+	params: CheckerTransformerParams,
+) => CheckerTransformerEither;
+
+export function createCheckerTransformer<
+	GenericChecker extends DataParserCheckers,
+>(
+	support: (checker: DataParserCheckers) => checker is GenericChecker,
+	builder: CheckerTransformerBuildFunction<GenericChecker>,
+) {
+	return (
+		checker: DataParserCheckers,
+		params: CheckerTransformerParams,
+	): CheckerTransformerEither => support(checker)
+		? builder(
+			checker as GenericChecker,
+			params,
+		)
+		: E.left("checkerNotSupport", checker);
+}

scripts/toDataParser/checkerTransformer/defaults/array/index.ts

@@ -0,0 +1,2 @@
+export * from "./max";
+export * from "./min";

scripts/toDataParser/checkerTransformer/defaults/array/max.ts

@@ -0,0 +1,28 @@
+import { DP } from "@duplojs/utils";
+import { createCheckerTransformer } from "../../create";
+import { factory } from "typescript";
+
+export const checkerArrayMaxTransformer = createCheckerTransformer(
+	DP.checkerArrayMaxKind.has,
+	(
+		checker,
+		{
+			success,
+			getDefinition,
+		},
+	) => {
+		const expression = factory.createCallExpression(
+			factory.createPropertyAccessExpression(
+				factory.createIdentifier("DP"),
+				factory.createIdentifier("checkerArrayMax"),
+			),
+			undefined,
+			[
+				factory.createNumericLiteral(checker.definition.max),
+				...getDefinition(),
+			],
+		);
+
+		return success(expression);
+	},
+);