@loydjs/vite 1.0.0 → 1.1.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@loydjs/vite",
-  "version": "1.0.0",
-  "description": "Loyd vite — Vite/Rollup AOT plugin",
+  "version": "1.1.0",
+  "description": "Loyd vite - Vite/Rollup AOT plugin",
   "keywords": [
     "loyd",
     "validation",
     "typescript",
-    "schema"
+    "vite"
   ],
   "license": "MIT",
   "type": "module",
@@ -32,16 +32,19 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@loydjs/core": "1.0.0",
-    "@loydjs/compiler": "1.0.0"
+    "magic-string": "^0.30.21",
+    "@loydjs/compiler": "1.1.0",
+    "@loydjs/core": "1.1.0"
   },
   "peerDependencies": {
     "vite": ">=5.0.0"
   },
   "devDependencies": {
-    "vite": "^5.4.11",
-    "typescript": "^5.7.2",
+    "@types/acorn": "^6.0.4",
+    "acorn": "^8.16.0",
     "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vite": "^5.4.11",
     "vitest": "^2.1.8"
   },
   "publishConfig": {

package/src/plugin.ts

@@ -1,41 +1,107 @@
-import { type AotTransformOptions, hasLoydImports, transformLoydImports } from "./transform.js";
+import type { LoydSchema } from "@loydjs/core";
+import { hasLoydImports, registerModuleSchemas, transformLoydImports } from "./transform.js";
+import type { AotTransformOptions } from "./transform.js";
+
 export interface LoydVitePluginOptions extends AotTransformOptions {
   enabled?: boolean;
   verbose?: boolean;
   cacheDir?: string;
+  /**
+   * @example
+   * loydPlugin({
+   *   schemas: {
+   *     UserSchema: UserSchema,
+   *     PostSchema: PostSchema,
+   *   }
+   * })
+   */
+  schemas?: Record<string, LoydSchema<unknown>>;
+  forceAot?: boolean;
 }
+
 export function loydPlugin(options: LoydVitePluginOptions = {}): unknown {
-  const { enabled = true, verbose = false, ...transformOptions } = options;
+  const {
+    enabled = true,
+    verbose = false,
+    schemas = {},
+    forceAot = false,
+    ...transformOptions
+  } = options;
+
+  let isBuild = false;
   let transformedCount = 0;
+  let skippedCount = 0;
+
+  const globalSchemas = new Map<string, LoydSchema<unknown>>(Object.entries(schemas));
+
   return {
     name: "loyd-vite-plugin",
     enforce: "pre" as const,
+
     configResolved(config: { command: string; mode: string }) {
-      if (verbose)
-        console.log(
-          `[@loydjs/vite] ${enabled ? "enabled" : "disabled"} — ${config.command === "build" ? "production (AOT)" : "development (JIT)"}`,
-        );
+      isBuild = config.command === "build";
+
+      if (verbose) {
+        const mode = isBuild || forceAot ? "AOT" : "JIT";
+        const status = enabled ? `enabled [${mode}]` : "disabled";
+        console.log(`[@loydjs/vite] ${status} — Vite ${config.command} (${config.mode})`);
+
+        if (globalSchemas.size > 0) {
+          console.log(
+            `[@loydjs/vite] Pre-registered schemas: ${[...globalSchemas.keys()].join(", ")}`,
+          );
+        }
+      }
     },
+
     transform(code: string, id: string): { code: string; map?: string } | null {
-      if (
-        !enabled ||
-        !/\.[jt]sx?$/.test(id) ||
-        id.includes("node_modules") ||
-        !hasLoydImports(code)
-      )
+      if (!enabled) return null;
+      if (!/\.[jt]sx?$/.test(id)) return null;
+      if (id.includes("node_modules")) return null;
+      if (!hasLoydImports(code)) return null;
+
+      if (!isBuild && !forceAot) {
+        return null;
+      }
+
+      if (globalSchemas.size > 0) {
+        registerModuleSchemas(id, globalSchemas);
+      }
+
+      const r = transformLoydImports(code, id, {
+        ...transformOptions,
+        verbose,
+      });
+
+      if (!r) {
+        skippedCount++;
         return null;
-      const r = transformLoydImports(code, id, { ...transformOptions, verbose });
-      if (!r) return null;
+      }
+
       transformedCount++;
-      if (verbose) console.log(`[@loydjs/vite] Transformed: ${id}`);
+
+      if (verbose) {
+        console.log(`[@loydjs/vite] AOT-transformed: ${id}`);
+      }
+
       return { code: r.code, map: r.map };
     },
+
     buildEnd() {
-      if (enabled && verbose && transformedCount > 0)
-        console.log(`[@loydjs/vite] Transformed ${transformedCount} files`);
+      if (!enabled || !verbose) return;
+
+      if (transformedCount > 0 || skippedCount > 0) {
+        console.log(
+          `[@loydjs/vite] Build complete — ${transformedCount} files AOT-transformed, ${skippedCount} files left to JIT`,
+        );
+      }
     },
+
     handleHotUpdate({ file }: { file: string }) {
-      if (enabled && verbose && hasLoydImports(file)) console.log(`[@loydjs/vite] HMR: ${file}`);
+      if (!enabled || !verbose) return;
+      if (hasLoydImports(file)) {
+        console.log(`[@loydjs/vite] HMR: ${file} (JIT mode)`);
+      }
     },
   };
 }

package/src/transform.ts

@@ -1,3 +1,9 @@
+import { generateInlineValidator } from "@loydjs/compiler";
+import type { LoydSchema } from "@loydjs/core";
+import { parse as parseAcorn } from "acorn";
+import type { CallExpression, Identifier, Node, Program, VariableDeclaration } from "acorn";
+import MagicString from "magic-string";
+
 export interface AotTransformOptions {
   outDir?: string;
   sourcemap?: boolean;
@@ -5,16 +11,28 @@ export interface AotTransformOptions {
   exclude?: string[];
   verbose?: boolean;
 }
+
 export interface AotTransformResult {
   code: string;
   map?: string;
   generatedFiles: string[];
 }
+
 export type AotTransformFn = (
   source: string,
   filename: string,
   options?: AotTransformOptions,
 ) => AotTransformResult | null;
+
+const _moduleSchemas = new Map<string, Map<string, LoydSchema<unknown>>>();
+
+export function registerModuleSchemas(
+  moduleId: string,
+  schemas: Map<string, LoydSchema<unknown>>,
+): void {
+  _moduleSchemas.set(moduleId, schemas);
+}
+
 export function hasLoydImports(source: string): boolean {
   return (
     source.includes("@loydjs/schema") ||
@@ -22,11 +40,169 @@ export function hasLoydImports(source: string): boolean {
     source.includes("@loydjs/compiler")
   );
 }
+
 export function transformLoydImports(
   source: string,
-  _filename: string,
-  _options: AotTransformOptions = {},
+  filename: string,
+  options: AotTransformOptions = {},
 ): AotTransformResult | null {
   if (!hasLoydImports(source)) return null;
-  return { code: `/* @loydjs/vite: AOT-ready */\n${source}`, generatedFiles: [] };
+
+  if (!source.includes("compile(")) return null;
+
+  let ast: Program;
+
+  try {
+    ast = parseAcorn(source, {
+      ecmaVersion: 2022,
+      sourceType: "module",
+    }) as Program;
+  } catch {
+    return transformLoydImportsFallback(source, filename, options);
+  }
+
+  const ms = new MagicString(source);
+  const schemas = _moduleSchemas.get(filename) ?? new Map<string, LoydSchema<unknown>>();
+  const generatedFiles: string[] = [];
+  let modified = false;
+
+  walkAst(ast, (node: Node) => {
+    if (node.type !== "VariableDeclaration") return;
+
+    const decl = node as VariableDeclaration;
+    for (const declarator of decl.declarations) {
+      if (
+        declarator.type !== "VariableDeclarator" ||
+        !declarator.init ||
+        declarator.init.type !== "CallExpression"
+      )
+        continue;
+
+      const call = declarator.init as CallExpression;
+      const callee = call.callee as Identifier;
+
+      if (callee.type !== "Identifier" || callee.name !== "compile") continue;
+      if (call.arguments.length === 0) continue;
+
+      const schemaArg = call.arguments[0] as Identifier;
+      if (schemaArg.type !== "Identifier") continue;
+
+      const schemaName = schemaArg.name;
+      const schema = schemas.get(schemaName);
+
+      if (!schema) {
+        if (options.verbose) {
+          console.log(
+            `[@loydjs/vite] Cannot resolve schema "${schemaName}" statically in ${filename}, falling back to JIT`,
+          );
+        }
+        continue;
+      }
+
+      const varNode = declarator.id as Identifier;
+      if (varNode.type !== "Identifier") continue;
+
+      const varName = varNode.name;
+
+      try {
+        const inlined = generateInlineValidator(schema, varName);
+
+        ms.overwrite(
+          (node as Node & { start: number }).start,
+          (node as Node & { end: number }).end,
+          inlined,
+        );
+        modified = true;
+
+        if (options.verbose) {
+          console.log(
+            `[@loydjs/vite] AOT-inlined validator for "${varName}" (${schema._type}) in ${filename}`,
+          );
+        }
+      } catch (err) {
+        if (options.verbose) {
+          console.warn(`[@loydjs/vite] Failed to inline "${varName}" in ${filename}:`, err);
+        }
+      }
+    }
+  });
+
+  if (!modified) return null;
+
+  if (!ms.toString().includes("compile(")) {
+    removeCompileImport(ms, ast, source);
+  }
+
+  const result: AotTransformResult = {
+    code: ms.toString(),
+    generatedFiles,
+  };
+
+  if (options.sourcemap !== false) {
+    result.map = ms.generateMap({ source: filename, includeContent: true }).toString();
+  }
+
+  return result;
+}
+
+function transformLoydImportsFallback(
+  source: string,
+  _filename: string,
+  _options: AotTransformOptions,
+): AotTransformResult | null {
+  return {
+    code: `/* @loydjs/vite: AOT-ready (JIT fallback) */\n${source}`,
+    generatedFiles: [],
+  };
+}
+
+//Remove compile import
+
+function removeCompileImport(ms: MagicString, ast: Program, _source: string): void {
+  walkAst(ast, (node: Node) => {
+    if (node.type !== "ImportDeclaration") return;
+
+    const imp = node as Node & {
+      source: { value: string };
+      specifiers: Array<Node & { imported: Identifier; local: Identifier }>;
+      start: number;
+      end: number;
+    };
+
+    if (imp.source.value !== "@loydjs/compiler") return;
+
+    const remaining = imp.specifiers.filter((s) => s.imported?.name !== "compile");
+
+    if (remaining.length === 0) {
+      ms.remove(imp.start, imp.end + 1); // +1 pour le \n
+    } else {
+      const names = remaining
+        .map((s) =>
+          s.imported.name === s.local.name
+            ? s.imported.name
+            : `${s.imported.name} as ${s.local.name}`,
+        )
+        .join(", ");
+      ms.overwrite(imp.start, imp.end, `import { ${names} } from "@loydjs/compiler"`);
+    }
+  });
+}
+
+function walkAst(node: Node, visitor: (node: Node) => void): void {
+  visitor(node);
+
+  for (const key of Object.keys(node)) {
+    const child = (node as unknown as Record<string, unknown>)[key];
+    if (child && typeof child === "object") {
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && "type" in item) {
+            walkAst(item as Node, visitor);
+          }
+        }
+      } else if ("type" in child) {
+        walkAst(child as Node, visitor);
+      }
+    }
+  }
 }