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 userDataParser = 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,40 @@
+import * as DP from "@duplojs/utils/dataParser";
+
+export type RecursiveType0 = {
+    id: string;
+    replies: RecursiveType0[];
+};
+
+export type $recursive1DataParser = RecursiveType0;
+
+export type RecursiveType2 = [
+    string,
+    RecursiveType2[]
+];
+
+export type $recursive2DataParser = RecursiveType2;
+
+export type RecursiveType4 = {
+    name: string;
+    children: RecursiveType4[];
+    comment: RecursiveType0;
+    meta: RecursiveType2;
+};
+
+export type $recursive0DataParser = RecursiveType4;
+
+export const recursive1DataParser: DP.DataParser<$recursive1DataParser> = DP.object({
+    id: DP.string(),
+    replies: DP.array(DP.lazy(() => recursive1DataParser))
+});
+
+export const recursive2DataParser: DP.DataParser<$recursive2DataParser> = DP.tuple([DP.string(), DP.array(DP.lazy(() => recursive2DataParser))]);
+
+export const recursive0DataParser: DP.DataParser<$recursive0DataParser> = DP.object({
+    name: DP.string(),
+    children: DP.array(DP.lazy(() => recursive0DataParser)),
+    comment: DP.lazy(() => recursive1DataParser),
+    meta: DP.lazy(() => recursive2DataParser)
+});
+
+export const recursiveNodeDataParser = recursive0DataParser;

integration/toDataParser/__snapshots__/withIdentifier.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,131 @@
+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 userDataParser = 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(),
+		});
+
+		const result = render(
+			userDataParser,
+			{
+				identifier: "user",
+				dataParserTransformers: defaultTransformers,
+				checkerTransformers: defaultCheckerTransformers,
+				typescriptTransformers: 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: DPE.lazy(() => commentSchema),
+			meta: DPE.lazy(() => metaSchema),
+		});
+
+		const result = render(
+			nodeSchema,
+			{
+				identifier: "recursiveNode",
+				dataParserTransformers: defaultTransformers,
+				checkerTransformers: defaultCheckerTransformers,
+				typescriptTransformers: tsDefaultTransformers,
+			},
+		);
+
+		await typedSnapshot(result, "__snapshots__/recursive.gen.ts");
+	});
+
+	it("divide with identifier", async() => {
+		const userRoleDataParser = DPE.literal(["admin", "editor", "viewer"]).addIdentifier("userRole");
+
+		const userDataParser = DPE.object({
+			id: DPE.templateLiteral(["user-", DPE.number(), "-db1"]),
+			name: DPE.string().min(2),
+			email: DPE.email(),
+			role: userRoleDataParser,
+		});
+
+		const result = render(
+			userDataParser,
+			{
+				identifier: "user",
+				dataParserTransformers: defaultTransformers,
+				checkerTransformers: defaultCheckerTransformers,
+				typescriptTransformers: tsDefaultTransformers,
+			},
+		);
+
+		await typedSnapshot(result, "__snapshots__/withIdentifier.gen.ts");
+	});
+});

integration/toTypescript/__snapshots__/index.test.ts.snap

@@ -1,7 +1,7 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`integration 1`] = `
-"import type { TheDate, TheTime } from "@duplojs/utils/date";
+"import { TheDate, TheTime } from "@duplojs/utils/date";
 
 export type UserProfile = {
     id: \`user-\${number}-db1\`;

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": [
@@ -71,7 +76,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.8.1 <2.0.0",
+    "@duplojs/utils": ">=1.8.4 <2.0.0",
     "@duplojs/server-utils": ">=0.3.0 < 1.0.0"
   },
   "dependencies": {

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";