@tuyau/core 0.1.0 → 0.1.2

package/build/commands/generate.js

@@ -3,6 +3,7 @@ import {
 } from "../chunk-3KNDPG6Y.js";
 
 // commands/generate.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { Project, QuoteKind } from "ts-morph";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 
@@ -30,13 +31,13 @@ var ApiTypesGenerator = class {
     this.#prepareDestination();
   }
   #getDestinationDirectory() {
-    return dirname(this.#destination.pathname);
+    return dirname(this.#destination);
   }
   /**
    * Create the destination directory if it does not exists
    */
   #prepareDestination() {
-    this.#destination = new URL("./.adonisjs/api.ts", this.#appRoot);
+    this.#destination = fileURLToPath(new URL("./.adonisjs/api.ts", this.#appRoot));
     const directory = this.#getDestinationDirectory();
     if (!existsSync(directory)) {
       mkdirSync(directory, { recursive: true });
@@ -109,34 +110,59 @@ var ApiTypesGenerator = class {
     return interfaceContent;
   }
   /**
-   * Filter routes to generate based on the ignoreRoutes config
+   * Filter routes to generate based on the config
    */
-  #filterRoutesToGenerate(routes) {
+  #filterRoutes(routes, mode) {
+    const config = this.#config.codegen?.[mode];
+    if (!config || !config.only && !config.except)
+      return routes;
     return routes.filter((route) => {
-      if (!this.#config.codegen?.ignoreRoutes)
-        return true;
-      if (typeof this.#config.codegen?.ignoreRoutes === "function") {
-        return !this.#config.codegen.ignoreRoutes(route);
+      if (typeof config.only === "function")
+        return config.only(route);
+      if (typeof config.except === "function")
+        return !config.except(route);
+      if (config.only) {
+        for (const pattern of config.only) {
+          if (pattern instanceof RegExp && pattern.test(route.pattern))
+            return true;
+          if (route.pattern === pattern)
+            return true;
+        }
+        return false;
       }
-      for (const ignore of this.#config.codegen.ignoreRoutes) {
-        if (typeof ignore === "string" && route.pattern === ignore)
-          return false;
-        if (ignore instanceof RegExp && ignore.test(route.pattern))
-          return false;
+      if (config.except) {
+        for (const pattern of config.except) {
+          if (pattern instanceof RegExp && pattern.test(route.pattern))
+            return false;
+          if (route.pattern === pattern)
+            return false;
+        }
+        return true;
       }
       return true;
     });
   }
-  #generateRoutesNameArray(routes) {
+  /**
+   * Generate a type name based on the route pattern and methods
+   *
+   * GET /users/:id => UsersIdGet
+   */
+  #generateTypeName(route) {
+    const remappedSegments = route.pattern.split("/").filter(Boolean).map((segment) => segment.startsWith(":") ? "id" : segment).join(" ");
+    const methods = string.pascalCase(route.methods.join(" "));
+    return string.pascalCase(remappedSegments) + methods;
+  }
+  #generateRoutesNameArray(routes, typesByPattern) {
     return routes.map(({ name, pattern, methods }) => {
       const params = matchit.parse(pattern).filter((node) => node.type !== 0).map((node) => node.val);
-      const typeName = string.pascalCase(string.slug(pattern)) + string.pascalCase(methods.join(" "));
+      let typeName = this.#generateTypeName({ pattern, methods });
+      if (!typesByPattern[typeName])
+        typeName = "unknown";
       return { params, name, path: pattern, method: methods, types: typeName };
     }).filter((route) => !!route.name);
   }
   async #writeApiFile(options) {
-    const path = fileURLToPath(this.#destination);
-    const file = this.#project.createSourceFile(path, "", { overwrite: true });
+    const file = this.#project.createSourceFile(this.#destination, "", { overwrite: true });
     if (!file)
       throw new Error("Unable to create the api.ts file");
     file.removeText().insertText(0, (writer) => {
@@ -147,7 +173,7 @@ var ApiTypesGenerator = class {
         writer.writeLine(`  response: ${value.response}`);
         writer.writeLine(`}`);
       });
-      writer.writeLine(`interface AdonisApi {`).write(this.#generateDefinitionInterface(options.definition, "  ")).writeLine(`}`);
+      writer.writeLine(`export interface ApiDefinition {`).write(this.#generateDefinitionInterface(options.definition, "  ")).writeLine(`}`);
       writer.writeLine(`const routes = [`);
       for (const route of options.routesNameArray) {
         writer.writeLine(`  {`);
@@ -159,7 +185,11 @@ var ApiTypesGenerator = class {
         writer.writeLine(`  },`);
       }
       writer.writeLine(`] as const;`);
-      writer.writeLine(`export const api = {`).writeLine(`  routes,`).writeLine(`  definition: {} as AdonisApi`).writeLine(`}`);
+      writer.writeLine(`export const api = {`).writeLine(`  routes,`).writeLine(`  definition: {} as ApiDefinition`).writeLine(`}`);
+      writer.writeLine(`declare module '@tuyau/inertia/types' {`);
+      writer.writeLine(`  type ApiDefinition = typeof api`);
+      writer.writeLine(`  export interface Api extends ApiDefinition {}`);
+      writer.writeLine(`}`);
     });
     await file.save();
   }
@@ -167,7 +197,7 @@ var ApiTypesGenerator = class {
     const definition = {};
     const typesByPattern = {};
     const sourcesFiles = this.#project.getSourceFiles();
-    const routes = this.#filterRoutesToGenerate(this.#routes);
+    const routes = this.#filterRoutes(this.#routes, "definitions");
     for (const route of routes) {
       if (typeof route.handler === "function")
         continue;
@@ -196,22 +226,21 @@ var ApiTypesGenerator = class {
         currentLevel = currentLevel[segment];
         if (i !== segments.length - 1)
           return;
-        const typeName = string.pascalCase(string.slug(route.pattern)) + string.pascalCase(methods.join(""));
+        const typeName = this.#generateTypeName(route);
         typesByPattern[typeName] = {
           request: schemaImport ? `MakeTuyauRequest<${schemaImport}>` : "unknown",
           response: `MakeTuyauResponse<import('${relativePath}').default['${routeHandler.method}']>`
         };
         currentLevel.$url = {};
-        for (const method of methods) {
-          currentLevel[method] = `${string.pascalCase(typeName)}`;
-        }
+        for (const method of methods)
+          currentLevel[method] = typeName;
       });
     }
-    await this.#writeApiFile({
-      definition,
-      typesByPattern,
-      routesNameArray: this.#generateRoutesNameArray(routes)
-    });
+    const routesNameArray = this.#generateRoutesNameArray(
+      this.#filterRoutes(routes, "routes"),
+      typesByPattern
+    );
+    await this.#writeApiFile({ definition, typesByPattern, routesNameArray });
   }
 };
 
@@ -234,7 +263,7 @@ var CodegenTypes = class extends BaseCommand {
   async run() {
     const project = new Project({
       manipulationSettings: { quoteKind: QuoteKind.Single },
-      tsConfigFilePath: new URL("./tsconfig.json", this.app.appRoot).pathname
+      tsConfigFilePath: fileURLToPath2(new URL("./tsconfig.json", this.app.appRoot))
     });
     const apiTypesGenerator = new ApiTypesGenerator({
       project,

package/build/{stubs/config → config}/tuyau.stub

@@ -6,9 +6,14 @@ import { defineConfig } from '@tuyau/core'
 const tuyauConfig = defineConfig({
   codegen: {
     /**
-     * List of routes to ignore during code generation
+     * Filters the definitions and named routes to be generated
      */
-    ignoreRoutes: []
+    // definitions: {
+    //  only: [],
+    // }
+    // routes: {
+    //  only: [],
+    // }
   }
 })
 

package/build/src/types.d.ts

@@ -1,12 +1,25 @@
 import { RouteJSON } from '@adonisjs/core/types/http';
 
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+type FilterConfig<FilterType> = XOR<{
+    only: FilterType;
+}, {
+    except: FilterType;
+}>;
 interface TuyauConfig {
     codegen?: {
         /**
-         * List of routes to ignore during code generation
+         * Filters the definitions to be generated
          */
-        ignoreRoutes?: Array<string | RegExp> | ((route: RouteJSON) => boolean);
+        definitions?: FilterConfig<Array<string | RegExp> | ((route: RouteJSON) => boolean)>;
+        /**
+         * Filters the named routes to be generated
+         */
+        routes?: FilterConfig<Array<string | RegExp> | ((route: RouteJSON) => boolean)>;
     };
 }
 
-export type { TuyauConfig };
+export type { FilterConfig, TuyauConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuyau/core",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "",
   "author": "",
   "license": "MIT",
@@ -31,8 +31,8 @@
     "@poppinss/cliui": "^6.4.1",
     "@poppinss/matchit": "^3.1.2",
     "@types/node": "^20.12.7",
-    "@tuyau/utils": "0.0.4",
-    "@tuyau/client": "0.1.0"
+    "@tuyau/client": "0.1.1",
+    "@tuyau/utils": "0.0.4"
   },
   "publishConfig": {
     "access": "public",
@@ -62,7 +62,7 @@
   },
   "scripts": {
     "clean": "del-cli build",
-    "copy:templates": "copyfiles \"stubs/**/*.stub\" build",
+    "copy:templates": "copyfiles --up 1 \"stubs/**/*.stub\" build",
     "typecheck": "tsc --noEmit",
     "format": "prettier --write .",
     "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",