@tuyau/core 0.4.2 → 1.0.0-beta.0

package/build/commands/generate.js

@@ -1,362 +0,0 @@
-import {
-  __decorateClass
-} from "../chunk-ADS4GRIL.js";
-
-// commands/generate.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { Project, QuoteKind } from "ts-morph";
-import { BaseCommand, flags } from "@adonisjs/core/ace";
-
-// src/codegen/api_types_generator.ts
-import { Node } from "ts-morph";
-import matchit from "@poppinss/matchit";
-import { fileURLToPath } from "url";
-import { readFile } from "fs/promises";
-import { dirname, relative } from "path";
-import { existsSync, mkdirSync } from "fs";
-import string from "@adonisjs/core/helpers/string";
-import { assertExists } from "@adonisjs/core/helpers/assert";
-import { parseBindingReference, slash } from "@adonisjs/core/helpers";
-var ApiTypesGenerator = class {
-  #appRoot;
-  #logger;
-  #project;
-  #config;
-  #routes;
-  #destination;
-  #cachedPkgJson;
-  constructor(options) {
-    this.#config = options.config;
-    this.#routes = options.routes;
-    this.#logger = options.logger;
-    this.#project = options.project;
-    this.#appRoot = options.appRoot;
-    this.#prepareDestination();
-  }
-  async #loadPkgJson() {
-    if (this.#cachedPkgJson) return this.#cachedPkgJson;
-    try {
-      const pkgJsonText = await readFile(
-        fileURLToPath(new URL("./package.json", this.#appRoot)),
-        "utf-8"
-      );
-      this.#cachedPkgJson = JSON.parse(pkgJsonText);
-      return this.#cachedPkgJson;
-    } catch (error) {
-      throw new Error("Unable to read the package.json file", { cause: error });
-    }
-  }
-  #isPackageInstalled(name) {
-    assertExists(
-      this.#cachedPkgJson,
-      "package.json should be loaded before checking if a package is installed"
-    );
-    return !!this.#cachedPkgJson.dependencies?.[name];
-  }
-  #getDestinationDirectory() {
-    return dirname(this.#destination);
-  }
-  /**
-   * Create the destination directory if it does not exists
-   */
-  #prepareDestination() {
-    this.#destination = fileURLToPath(new URL("./.adonisjs/api.ts", this.#appRoot));
-    const directory = this.#getDestinationDirectory();
-    if (!existsSync(directory)) {
-      mkdirSync(directory, { recursive: true });
-    }
-  }
-  /**
-   * Extract class and method of the route handler
-   */
-  #extractClassHandlerData(file, routeHandler) {
-    const classDef = file.getClasses().find((c) => c.isDefaultExport());
-    if (!classDef) return;
-    const method = classDef.getMethod(routeHandler.method);
-    if (!method) return;
-    const body = method.getBody();
-    if (!body) return;
-    return { method, body, file };
-  }
-  /**
-   * Get the import type of an identifier
-   */
-  #getIdentifierImportType(identifier) {
-    const sourceFile = identifier.getSourceFile();
-    const namedImport = sourceFile.getImportDeclaration((importNode) => {
-      const namedImports = importNode.getNamedImports();
-      if (namedImports.find((namedImport2) => namedImport2.getName() === identifier.getText())) {
-        return true;
-      }
-      return false;
-    });
-    const defaultImport = sourceFile.getImportDeclaration((importNode) => {
-      if (importNode.getDefaultImport()?.getText() === identifier.getText()) return true;
-      return false;
-    });
-    const isValidFile = (namedImport || defaultImport)?.getModuleSpecifierSourceFile();
-    if (!isValidFile) return void 0;
-    if (namedImport) return "named";
-    if (defaultImport) return "default";
-    return void 0;
-  }
-  /**
-   * This method will returns the path to the schema file
-   */
-  #extractRequest(handlerData) {
-    const validateUsingCallNode = handlerData.method.forEachDescendant((node) => {
-      if (!Node.isCallExpression(node)) return false;
-      if (node.getExpression().getText().includes("validateUsing")) {
-        return node;
-      }
-      return false;
-    });
-    if (!validateUsingCallNode) return;
-    const schema = validateUsingCallNode.getArguments()[0];
-    if (Node.isIdentifier(schema)) {
-      const definition = schema.getDefinitions().at(0);
-      const importType = this.#getIdentifierImportType(schema);
-      const isReExportedFromThisFile = definition ? handlerData.file.getExportedDeclarations().has(definition.getNode().getText()) : false;
-      if (!importType && !isReExportedFromThisFile) {
-        this.#logger.warning(`Unable to find the schema file for ${schema.getText()}`);
-        return;
-      }
-      const importPath = definition.getSourceFile().getFilePath();
-      const relativeImportPath = slash(relative(this.#getDestinationDirectory(), importPath));
-      const propName = importType === "default" ? "default" : schema.getText();
-      return `InferInput<typeof import('${relativeImportPath}')['${propName}']>`;
-    }
-    if (Node.isPropertyAccessExpression(schema)) {
-      const baseExpression = schema.getExpression();
-      const propertyName = schema.getName();
-      if (Node.isIdentifier(baseExpression)) {
-        const className = baseExpression.getText();
-        const classDeclaration = handlerData.file.getClass(className);
-        if (!classDeclaration) return;
-        const staticProperty = classDeclaration.getStaticMember(propertyName);
-        if (!staticProperty) return;
-        const importPath = classDeclaration.getSourceFile().getFilePath();
-        const relativeImportPath = slash(relative(this.#getDestinationDirectory(), importPath));
-        return `InferInput<typeof import('${relativeImportPath}').default['${propertyName}']>`;
-      }
-    }
-  }
-  /**
-   * Generate the final interface containing all routes, request, and response
-   */
-  #generateDefinitionInterface(types, indent = "  ") {
-    let interfaceContent = "";
-    Object.entries(types).forEach(([key, value]) => {
-      if (typeof value === "object") {
-        interfaceContent += `${indent}'${key}': {
-`;
-        interfaceContent += this.#generateDefinitionInterface(value, indent + "  ");
-        interfaceContent += `${indent}};
-`;
-      } else {
-        interfaceContent += `${indent}'${key}': ${value};
-`;
-      }
-    });
-    return interfaceContent;
-  }
-  /**
-   * Filter routes to generate based on the config
-   */
-  #filterRoutes(routes, mode) {
-    const config = this.#config.codegen?.[mode];
-    if (!config || !config.only && !config.except) return routes;
-    return routes.filter((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;
-      }
-      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;
-    });
-  }
-  /**
-   * 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);
-      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 #writeIndexFile() {
-    const filePath = this.#getDestinationDirectory() + "/index.ts";
-    const exist = existsSync(filePath);
-    if (exist) {
-      return;
-    }
-    const file = this.#project.createSourceFile(filePath, "", {
-      overwrite: true
-    });
-    if (!file) throw new Error("Unable to create the index.ts file");
-    file.removeText().insertText(0, (writer) => {
-      writer.writeLine(`/// <reference path="../adonisrc.ts" />`);
-      writer.newLine();
-      writer.writeLine(`export * from './api.js'`);
-    });
-    await file.save();
-  }
-  /**
-   * If @tuyau/superjson is installed then we must use a special
-   * type that will not type-serialize the response
-   */
-  #getMakeTuyauResponseType() {
-    const isSuperJsonInstalled = this.#isPackageInstalled("@tuyau/superjson");
-    return isSuperJsonInstalled ? "MakeNonSerializedTuyauResponse" : "MakeTuyauResponse";
-  }
-  async #writeApiFile(options) {
-    const file = this.#project.createSourceFile(this.#destination, "", { overwrite: true });
-    if (!file) throw new Error("Unable to create the api.ts file");
-    const isTuyauInertiaInstalled = this.#isPackageInstalled("@tuyau/inertia");
-    const makeTuyauResponseType = this.#getMakeTuyauResponseType();
-    file.removeText().insertText(0, (writer) => {
-      writer.writeLine(`// @ts-nocheck`).writeLine(`/* eslint-disable */`).writeLine("// --------------------------------------------------").writeLine("// This file is auto-generated by Tuyau. Do not edit manually !").writeLine("// --------------------------------------------------").writeLine("").writeLine(
-        `import type { MakeTuyauRequest, ${makeTuyauResponseType} } from '@tuyau/utils/types'`
-      ).writeLine(`import type { InferInput } from '@vinejs/vine/types'`).newLine();
-      Object.entries(options.typesByPattern).forEach(([key, value]) => {
-        writer.writeLine(`type ${key} = {`);
-        writer.writeLine(`  request: ${value.request}`);
-        writer.writeLine(`  response: ${value.response}`);
-        writer.writeLine(`}`);
-      });
-      writer.writeLine(`export interface ApiDefinition {`).write(this.#generateDefinitionInterface(options.definition, "  ")).writeLine(`}`);
-      writer.writeLine(`const routes = [`);
-      for (const route of options.routesNameArray) {
-        writer.writeLine(`  {`);
-        writer.writeLine(`    params: ${JSON.stringify(route.params)},`);
-        writer.writeLine(`    name: '${route.name}',`);
-        writer.writeLine(`    path: '${route.path}',`);
-        writer.writeLine(`    method: ${JSON.stringify(route.method)},`);
-        writer.writeLine(`    types: {} as ${route.types},`);
-        writer.writeLine(`  },`);
-      }
-      writer.writeLine(`] as const;`);
-      writer.writeLine(`export const api = {`).writeLine(`  routes,`).writeLine(`  definition: {} as ApiDefinition`).writeLine(`}`);
-      if (isTuyauInertiaInstalled) {
-        writer.writeLine(`declare module '@tuyau/inertia/types' {`);
-        writer.writeLine(`  type InertiaApi = typeof api`);
-        writer.writeLine(`  export interface Api extends InertiaApi {}`);
-        writer.writeLine(`}`);
-      }
-    });
-    await file.save();
-  }
-  async generate() {
-    const definition = {};
-    const typesByPattern = {};
-    const sourcesFiles = this.#project.getSourceFiles();
-    const routes = this.#filterRoutes(this.#routes, "definitions");
-    await this.#loadPkgJson();
-    for (const route of routes) {
-      if (typeof route.handler === "function") continue;
-      const routeHandler = await parseBindingReference(route.handler.reference);
-      const file = sourcesFiles.find((sf) => {
-        const filePath = sf.getFilePath();
-        if (routeHandler.moduleNameOrPath.startsWith("./")) {
-          return filePath.endsWith(
-            routeHandler.moduleNameOrPath.replace("./", "").replace(".js", ".ts")
-          );
-        }
-        return filePath.endsWith(`${routeHandler.moduleNameOrPath.replace("#", "")}.ts`);
-      });
-      if (!file) {
-        this.#logger.warning(`Unable to find the controller file for ${route.pattern}`);
-        continue;
-      }
-      this.#logger.info(`Generating types for ${route.pattern}`);
-      const handlerData = this.#extractClassHandlerData(file, routeHandler);
-      if (!handlerData) {
-        this.#logger.warning(`Unable to find the controller method for ${route.pattern}`);
-        continue;
-      }
-      const schemaImport = this.#extractRequest(handlerData);
-      const methods = route.methods.map((method) => "$" + method.toLowerCase()).filter((method) => method !== "head");
-      const segments = route.pattern.split("/").filter(Boolean);
-      let currentLevel = definition;
-      const relativePath = slash(relative(this.#getDestinationDirectory(), file.getFilePath()));
-      segments.forEach((segment, i) => {
-        if (!currentLevel[segment]) currentLevel[segment] = {};
-        currentLevel = currentLevel[segment];
-        if (i !== segments.length - 1) return;
-        const typeName = this.#generateTypeName(route);
-        const makeTuyauResponseType = this.#getMakeTuyauResponseType();
-        typesByPattern[typeName] = {
-          request: schemaImport ? `MakeTuyauRequest<${schemaImport}>` : "unknown",
-          response: `${makeTuyauResponseType}<import('${relativePath}').default['${routeHandler.method}'], ${!!schemaImport}>`
-        };
-        currentLevel.$url = {};
-        for (const method of methods) currentLevel[method] = typeName;
-      });
-    }
-    const routesNameArray = this.#generateRoutesNameArray(
-      this.#filterRoutes(routes, "routes"),
-      typesByPattern
-    );
-    await this.#writeApiFile({ definition, typesByPattern, routesNameArray });
-    await this.#writeIndexFile();
-  }
-};
-
-// commands/generate.ts
-var CodegenTypes = class extends BaseCommand {
-  static commandName = "tuyau:generate";
-  static description = "Tuyau generator command";
-  static options = { startApp: true };
-  /**
-   * Get routes from the router instance
-   */
-  async #getRoutes() {
-    const router = await this.app.container.make("router");
-    router.commit();
-    return router.toJSON().root;
-  }
-  /**
-   * Execute command
-   */
-  async run() {
-    const project = new Project({
-      manipulationSettings: { quoteKind: QuoteKind.Single },
-      tsConfigFilePath: fileURLToPath2(new URL("./tsconfig.json", this.app.appRoot))
-    });
-    const apiTypesGenerator = new ApiTypesGenerator({
-      project,
-      logger: this.logger,
-      appRoot: this.app.appRoot,
-      routes: await this.#getRoutes(),
-      config: this.app.config.get("tuyau")
-    });
-    await apiTypesGenerator.generate();
-    this.logger.success("Types generated successfully");
-  }
-};
-__decorateClass([
-  flags.boolean({ description: "Verbose logs", default: false, alias: "v" })
-], CodegenTypes.prototype, "verbose", 2);
-export {
-  CodegenTypes as default
-};

package/build/config/tuyau.stub

@@ -1,20 +0,0 @@
-{{{
-  exports({ to: app.configPath('tuyau.ts') })
-}}}
-import { defineConfig } from '@tuyau/core'
-
-const tuyauConfig = defineConfig({
-  codegen: {
-    /**
-     * Filters the definitions and named routes to be generated
-     */
-    // definitions: {
-    //  only: [],
-    // }
-    // routes: {
-    //  only: [],
-    // }
-  }
-})
-
-export default tuyauConfig

package/build/index.d.ts

@@ -1,9 +0,0 @@
-import ConfigureCommand from '@adonisjs/core/commands/configure';
-import { TuyauConfig } from './src/types.js';
-import '@adonisjs/core/types/http';
-
-declare function configure(command: ConfigureCommand): Promise<void>;
-
-declare function defineConfig(options: TuyauConfig): TuyauConfig;
-
-export { configure, defineConfig };

package/build/index.js

@@ -1,30 +0,0 @@
-import "./chunk-ADS4GRIL.js";
-
-// stubs/main.ts
-import { getDirname } from "@adonisjs/core/helpers";
-var stubsRoot = getDirname(import.meta.url);
-
-// configure.ts
-async function configure(command) {
-  const codemods = await command.createCodemods();
-  await codemods.updateRcFile((rcFile) => {
-    rcFile.addCommand("@tuyau/core/commands");
-    rcFile.addProvider("@tuyau/core/tuyau_provider");
-  });
-  await codemods.installPackages([
-    {
-      isDevDependency: true,
-      name: "@tuyau/utils"
-    }
-  ]);
-  await codemods.makeUsingStub(stubsRoot, "config/tuyau.stub", {});
-}
-
-// src/define_config.ts
-function defineConfig(options) {
-  return options;
-}
-export {
-  configure,
-  defineConfig
-};

package/build/providers/tuyau_provider.d.ts

@@ -1,190 +0,0 @@
-import { ApplicationService } from '@adonisjs/core/types';
-
-/**
- * Extending the HTTP response interface to include status and response
- * in the return type.
- *
- * This is ONLY type information and the properties will not be available
- * at runtime. This is needed to infer the correct response type
- */
-declare module '@adonisjs/core/http' {
-    interface Response {
-        continue(): {
-            __status: 100;
-        };
-        switchingProtocols(etag?: boolean): {
-            __status: 101;
-        };
-        ok<T>(body: T, etag?: boolean): {
-            __response: T;
-            __status: 200;
-        };
-        created<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 201;
-        };
-        accepted<T>(body: T, etag?: boolean): {
-            __response: T;
-            __status: 202;
-        };
-        nonAuthoritativeInformation<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 203;
-        };
-        noContent<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 204;
-        };
-        resetContent<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 205;
-        };
-        partialContent<T>(body: T, etag?: boolean): {
-            __response: T;
-            __status: 206;
-        };
-        multipleChoices<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 300;
-        };
-        movedPermanently<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 301;
-        };
-        movedTemporarily<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 302;
-        };
-        seeOther<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 303;
-        };
-        notModified<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 304;
-        };
-        useProxy<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 305;
-        };
-        temporaryRedirect<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 307;
-        };
-        badRequest<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 400;
-        };
-        unauthorized<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 401;
-        };
-        paymentRequired<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 402;
-        };
-        forbidden<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 403;
-        };
-        notFound<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 404;
-        };
-        methodNotAllowed<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 405;
-        };
-        notAcceptable<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 406;
-        };
-        proxyAuthenticationRequired<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 407;
-        };
-        requestTimeout<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 408;
-        };
-        conflict<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 409;
-        };
-        gone<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 410;
-        };
-        lengthRequired<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 411;
-        };
-        preconditionFailed<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 412;
-        };
-        requestEntityTooLarge<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 413;
-        };
-        requestUriTooLong<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 414;
-        };
-        unsupportedMediaType<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 415;
-        };
-        requestedRangeNotSatisfiable<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 416;
-        };
-        expectationFailed<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 417;
-        };
-        unprocessableEntity<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 422;
-        };
-        tooManyRequests<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 429;
-        };
-        internalServerError<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 500;
-        };
-        notImplemented<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 501;
-        };
-        badGateway<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 502;
-        };
-        serviceUnavailable<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 503;
-        };
-        gatewayTimeout<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 504;
-        };
-        httpVersionNotSupported<T>(body?: T, etag?: boolean): {
-            __response: T;
-            __status: 505;
-        };
-        json<T>(body: T, generateEtag?: boolean): {
-            __response: T;
-            __status: 200;
-        };
-    }
-}
-declare class TuyauProvider {
-    protected app: ApplicationService;
-    constructor(app: ApplicationService);
-    register(): Promise<void>;
-}
-
-export { TuyauProvider as default };

package/build/providers/tuyau_provider.js

@@ -1,13 +0,0 @@
-import "../chunk-ADS4GRIL.js";
-
-// providers/tuyau_provider.ts
-var TuyauProvider = class {
-  constructor(app) {
-    this.app = app;
-  }
-  async register() {
-  }
-};
-export {
-  TuyauProvider as default
-};

package/build/src/hooks/build_hook.d.ts

@@ -1,5 +0,0 @@
-import { AssemblerHookHandler } from '@adonisjs/core/types/app';
-
-declare function tuyauBuildHook({ logger }: Parameters<AssemblerHookHandler>[0]): Promise<void>;
-
-export { tuyauBuildHook as default };

package/build/src/hooks/build_hook.js

@@ -1,14 +0,0 @@
-import "../../chunk-ADS4GRIL.js";
-
-// src/hooks/build_hook.ts
-import util from "util";
-import { exec as cpExec } from "child_process";
-var exec = util.promisify(cpExec);
-async function tuyauBuildHook({ logger }) {
-  logger.info("generating tuyau codegen file", { suffix: "tuyau" });
-  const { stderr } = await exec("node ace tuyau:generate");
-  if (stderr) throw new Error(stderr);
-}
-export {
-  tuyauBuildHook as default
-};

package/build/src/types.d.ts

@@ -1,25 +0,0 @@
-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?: {
-        /**
-         * Filters the definitions to be generated
-         */
-        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 { FilterConfig, TuyauConfig };