@tuyau/core 0.0.4

package/README.md

@@ -0,0 +1,115 @@
+# AdonisJS package starter kit
+
+> A boilerplate for creating AdonisJS packages
+
+This repo provides you with a starting point for creating AdonisJS packages. Of course, you can create a package from scratch with your folder structure and workflow. However, using this starter kit can speed up the process, as you have fewer decisions to make.
+
+## Setup
+
+- Clone the repo on your computer, or use `giget` to download this repo without the Git history.
+  ```sh
+  npx giget@latest gh:adonisjs/pkg-starter-kit
+  ```
+- Install dependencies.
+- Update the `package.json` file and define the `name`, `description`, `keywords`, and `author` properties.
+- The repo is configured with an MIT license. Feel free to change that if you are not publishing under the MIT license.
+
+## Folder structure
+
+The starter kit mimics the folder structure of the official packages. Feel free to rename files and folders as per your requirements.
+
+```
+├── providers
+├── src
+├── bin
+├── stubs
+├── configure.ts
+├── index.ts
+├── LICENSE.md
+├── package.json
+├── README.md
+├── tsconfig.json
+├── tsnode.esm.js
+```
+
+- The `configure.ts` file exports the `configure` hook to configure the package using the `node ace configure` command.
+- The `index.ts` file is the main entry point of the package.
+- The `tsnode.esm.js` file runs TypeScript code using TS-Node + SWC. Please read the code comment in this file to learn more.
+- The `bin` directory contains the entry point file to run Japa tests.
+- Learn more about [the `providers` directory](./providers/README.md).
+- Learn more about [the `src` directory](./src/README.md).
+- Learn more about [the `stubs` directory](./stubs/README.md).
+
+### File system naming convention
+
+We use `snake_case` naming conventions for the file system. The rule is enforced using ESLint. However, turn off the rule and use your preferred naming conventions.
+
+## Peer dependencies
+
+The starter kit has a peer dependency on `@adonisjs/core@6`. Since you are creating a package for AdonisJS, you must make it against a specific version of the framework core.
+
+If your package needs Lucid to be functional, you may install `@adonisjs/lucid` as a development dependency and add it to the list of `peerDependencies`.
+
+As a rule of thumb, packages installed in the user application should be part of the `peerDependencies` of your package and not the main dependency.
+
+For example, if you install `@adonisjs/core` as a main dependency, then essentially, you are importing a separate copy of `@adonisjs/core` and not sharing the one from the user application. Here is a great article explaining [peer dependencies](https://blog.bitsrc.io/understanding-peer-dependencies-in-javascript-dbdb4ab5a7be).
+
+## Published files
+
+Instead of publishing your repo's source code to npm, you must cherry-pick files and folders to publish only the required files.
+
+The cherry-picking uses the `files` property inside the `package.json` file. By default, we publish the following files and folders.
+
+```json
+{
+  "files": ["build/src", "build/providers", "build/stubs", "build/index.d.ts", "build/index.js"]
+}
+```
+
+If you create additional folders or files, mention them inside the `files` array.
+
+## Exports
+
+[Node.js Subpath exports](https://nodejs.org/api/packages.html#subpath-exports) allows you to define the exports of your package regardless of the folder structure. This starter kit defines the following exports.
+
+```json
+{
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types.js"
+  }
+}
+```
+
+- The dot `.` export is the main export.
+- The `./types` exports all the types defined inside the `./build/src/types.js` file (the compiled output).
+
+Feel free to change the exports as per your requirements.
+
+## Testing
+
+We configure the [Japa test runner](https://japa.dev/) with this starter kit. Japa is used in AdonisJS applications as well. Just run one of the following commands to execute tests.
+
+- `npm run test`: This command will first lint the code using ESlint and then run tests and report the test coverage using [c8](https://github.com/bcoe/c8).
+- `npm run quick:test`: Runs only the tests without linting or coverage reporting.
+
+The starter kit also has a Github workflow file to run tests using Github Actions. The tests are executed against `Node.js 20.x` and `Node.js 21.x` versions on both Linux and Windows. Feel free to edit the workflow file in the `.github/workflows` directory.
+
+## TypeScript workflow
+
+- The starter kit uses [tsc](https://www.typescriptlang.org/docs/handbook/compiler-options.html) for compiling the TypeScript to JavaScript when publishing the package.
+- [TS-Node](https://typestrong.org/ts-node/) and [SWC](https://swc.rs/) are used to run tests without compiling the source code.
+- The `tsconfig.json` file is extended from [`@adonisjs/tsconfig`](https://github.com/adonisjs/tooling-config/tree/main/packages/typescript-config) and uses the `NodeNext` module system. Meaning the packages are written using ES modules.
+- You can perform type checking without compiling the source code using the `npm run type check` script.
+
+Feel free to explore the `tsconfig.json` file for all the configured options.
+
+## ESLint and Prettier setup
+
+The starter kit configures ESLint and Prettier. Both configurations are stored within the `package.json` file and use our [shared config](https://github.com/adonisjs/tooling-config/tree/main/packages). Feel free to change the configuration, use custom plugins, or remove both tools altogether.
+
+## Using Stale bot
+
+The [Stale bot](https://github.com/apps/stale) is a Github application that automatically marks issues and PRs as stale and closes after a specific duration of inactivity.
+
+Feel free to delete the `.github/stale.yml` and `.github/lock.yml` files if you decide not to use the Stale bot.

package/build/commands/commands.json

@@ -0,0 +1 @@
+{"commands":[{"commandName":"tuyau:generate","description":"Tuyau generator command","help":"","namespace":"tuyau","aliases":[],"flags":[],"args":[],"options":{"startApp":true},"filePath":"generate.js","absoluteFilePath":"/home/julien/code/adonis/tuyau/packages/core/build/commands/generate.js"}],"version":1}

package/build/commands/generate.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import { CommandOptions } from '@adonisjs/core/types/ace';
+
+declare class CodegenTypes extends BaseCommand {
+    #private;
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    /**
+     * Execute command
+     */
+    run(): Promise<void>;
+}
+
+export { CodegenTypes as default };

package/build/commands/generate.js

@@ -0,0 +1,216 @@
+// commands/generate.ts
+import { Project, QuoteKind } from "ts-morph";
+import { BaseCommand } from "@adonisjs/core/ace";
+
+// src/codegen/api_types_generator.ts
+import { Node } from "ts-morph";
+import { fileURLToPath } from "node:url";
+import { dirname, relative } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { parseBindingReference } from "@adonisjs/core/helpers";
+var ApiTypesGenerator = class {
+  #appRoot;
+  #logger;
+  #project;
+  #config;
+  #routes;
+  #destination;
+  constructor(options) {
+    this.#config = options.config;
+    this.#routes = options.routes;
+    this.#logger = options.logger;
+    this.#project = options.project;
+    this.#appRoot = options.appRoot;
+    this.#prepareDestination();
+  }
+  #getDestinationDirectory() {
+    return dirname(this.#destination.pathname);
+  }
+  /**
+   * Create the destination directory if it does not exists
+   */
+  #prepareDestination() {
+    this.#destination = new URL("./.adonisjs/types/api.d.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 };
+  }
+  /**
+   * We have multiple ways to get the request payload :
+   * - First we check if a FormRequest is used
+   * - Other we check if we have a Single Action Controller
+   * - Otherwise, we check if a request.validateUsing is used
+   *
+   * 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) {
+      const schema = validateUsingCallNode.getArguments()[0];
+      if (!Node.isIdentifier(schema))
+        return;
+      const importPath = schema.getImplementations()[0].getSourceFile().getFilePath();
+      const relativeImportPath = relative(this.#getDestinationDirectory(), importPath);
+      return `InferInput<typeof import('${relativeImportPath}')['${schema.getText()}']>`;
+    }
+    return void 0;
+  }
+  /**
+   * Generate the final interface containing all routes, request, and response
+   */
+  #generateFinalInterface(types, indent = "  ") {
+    let interfaceContent = "";
+    Object.entries(types).forEach(([key, value]) => {
+      if (typeof value === "object") {
+        interfaceContent += `${indent}'${key}': {
+`;
+        interfaceContent += this.#generateFinalInterface(value, indent + "  ");
+        interfaceContent += `${indent}};
+`;
+      } else {
+        interfaceContent += `${indent}'${key}': ${value};
+`;
+      }
+    });
+    return interfaceContent;
+  }
+  /**
+   * Write the final interface containing all routes, request, and response
+   * in a routes.d.ts file
+   */
+  async #writeFinalInterface(types) {
+    const file = this.#project.createSourceFile(fileURLToPath(this.#destination), "", {
+      overwrite: true
+    });
+    if (!file)
+      throw new Error("Unable to create the api.d.ts file");
+    file?.removeText();
+    file.insertText(0, (writer) => {
+      writer.writeLine(
+        `import type { MakeOptional, Serialize, Simplify, ConvertReturnTypeToRecordStatusResponse } from '@tuyau/utils/types'`
+      ).writeLine(`import type { InferInput } from '@vinejs/vine/types'`).newLine().writeLine(`export interface AdonisApi {`).write(this.#generateFinalInterface(types, "  ")).writeLine(`}`);
+    });
+    await file.save();
+  }
+  /**
+   * Filter routes to generate based on the ignoreRoutes config
+   */
+  #filterRoutesToGenerate(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);
+      }
+      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;
+      }
+      return true;
+    });
+  }
+  async generate() {
+    const types = {};
+    const sourcesFiles = this.#project.getSourceFiles();
+    const routes = this.#filterRoutesToGenerate(this.#routes);
+    for (const route of routes) {
+      if (typeof route.handler === "function")
+        continue;
+      const routeHandler = await parseBindingReference(route.handler.reference);
+      const file = sourcesFiles.find(
+        (sf) => sf.getFilePath().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 = types;
+      const relativePath = relative(this.#getDestinationDirectory(), file.getFilePath());
+      segments.forEach((segment, i) => {
+        if (!currentLevel[segment]) {
+          currentLevel[segment] = {};
+        }
+        currentLevel = currentLevel[segment];
+        if (i === segments.length - 1) {
+          for (const method of methods) {
+            currentLevel[method] = {
+              request: schemaImport ? `MakeOptional<${schemaImport}>` : "unknown",
+              response: `Simplify<Serialize<ConvertReturnTypeToRecordStatusResponse<Awaited<ReturnType<typeof import('${relativePath}').default['prototype']['${routeHandler.method}']>>>>>`
+            };
+          }
+        }
+      });
+    }
+    await this.#writeFinalInterface(types);
+  }
+};
+
+// 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({
+      tsConfigFilePath: new URL("./tsconfig.json", this.app.appRoot).pathname,
+      manipulationSettings: { quoteKind: QuoteKind.Single }
+    });
+    const apiTypesGenerator = new ApiTypesGenerator({
+      project,
+      appRoot: this.app.appRoot,
+      routes: await this.#getRoutes(),
+      config: this.app.config.get("tuyau"),
+      logger: this.logger
+    });
+    await apiTypesGenerator.generate();
+    this.logger.success("Types generated successfully");
+  }
+};
+export {
+  CodegenTypes as default
+};

package/build/commands/main.d.ts

@@ -0,0 +1,4 @@
+import { CommandMetaData, Command } from '@adonisjs/ace/types';
+
+export function getMetaData(): Promise<CommandMetaData[]>
+export function getCommand(metaData: CommandMetaData): Promise<Command | null>

package/build/commands/main.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * In-memory cache of commands after they have been loaded
+ */
+let commandsMetaData
+
+/**
+ * Reads the commands from the "./commands.json" file. Since, the commands.json
+ * file is generated automatically, we do not have to validate its contents
+ */
+export async function getMetaData() {
+  if (commandsMetaData) {
+    return commandsMetaData
+  }
+
+  const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8')
+  commandsMetaData = JSON.parse(commandsIndex).commands
+
+  return commandsMetaData
+}
+
+/**
+ * Imports the command by lookingup its path from the commands
+ * metadata
+ */
+export async function getCommand(metaData) {
+  const commands = await getMetaData()
+  const command = commands.find(({ commandName }) => metaData.commandName === commandName)
+  if (!command) {
+    return null
+  }
+
+  const { default: commandConstructor } = await import(new URL(command.filePath, import.meta.url).href)
+  return commandConstructor
+}

package/build/index.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,22 @@
+// 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.makeUsingStub(stubsRoot, "config/tuyau.stub", {});
+}
+
+// src/define_config.ts
+function defineConfig(options) {
+  return options;
+}
+export {
+  configure,
+  defineConfig
+};

package/build/providers/tuyau_provider.d.ts

@@ -0,0 +1,190 @@
+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

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

package/build/src/types.d.ts

@@ -0,0 +1,12 @@
+import { RouteJSON } from '@adonisjs/core/types/http';
+
+interface TuyauConfig {
+    codegen?: {
+        /**
+         * List of routes to ignore during code generation
+         */
+        ignoreRoutes?: Array<string | RegExp> | ((route: RouteJSON) => boolean);
+    };
+}
+
+export type { TuyauConfig };

package/build/stubs/config/tuyau.stub

@@ -0,0 +1,15 @@
+{{{
+  exports({ to: app.configPath('tuyau.ts') })
+}}}
+import { defineConfig } from '@tuyau/core'
+
+const tuyauConfig = defineConfig({
+  codegen: {
+    /**
+     * List of routes to ignore during code generation
+     */
+    ignoreRoutes: []
+  }
+})
+
+export default tuyauConfig

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@tuyau/core",
+  "type": "module",
+  "version": "0.0.4",
+  "description": "",
+  "author": "",
+  "license": "MIT",
+  "keywords": [],
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types.js",
+    "./commands": "./build/commands/main.js",
+    "./tuyau_provider": "./build/providers/tuyau_provider.js"
+  },
+  "files": [
+    "build"
+  ],
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "scripts": {
+    "clean": "del-cli build",
+    "copy:templates": "copyfiles \"stubs/**/*.stub\" build",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
+    "test": "c8 npm run quick:test",
+    "index:commands": "adonis-kit index build/commands",
+    "prebuild": "npm run clean",
+    "build": "pnpm clean && tsup-node && pnpm copy:templates && pnpm index:commands",
+    "release": "pnpm build && pnpm release-it",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@adonisjs/core": "^6.2.0"
+  },
+  "dependencies": {
+    "ts-morph": "^22.0.0"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^7.4.0",
+    "@adonisjs/core": "^6.5.0",
+    "@julr/tooling-configs": "^2.2.0",
+    "@poppinss/cliui": "^6.4.1",
+    "@poppinss/matchit": "^3.1.2",
+    "@tuyau/client": "workspace:*",
+    "@tuyau/utils": "workspace:*",
+    "@types/node": "^20.12.7"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore(release): @tuyau/core@${version}",
+      "tagAnnotation": "release ${version}",
+      "tagName": "@tuyau/core@${version}"
+    },
+    "github": {
+      "release": true,
+      "releaseName": "@tuyau/core@${version}",
+      "web": true
+    }
+  },
+  "tsup": {
+    "entry": [
+      "./index.ts",
+      "./src/types.ts",
+      "./commands/generate.ts",
+      "./providers/tuyau_provider.ts"
+    ],
+    "outDir": "./build",
+    "clean": false,
+    "format": "esm",
+    "dts": true,
+    "target": "esnext"
+  }
+}