@asterflow/fs 1.0.1

package/README.md

@@ -0,0 +1,121 @@
+<div align="center">
+
+# @asterflow/fs
+
+![license-info](https://img.shields.io/github/license/AsterFlow/plugins?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
+![stars-info](https://img.shields.io/github/stars/AsterFlow/plugins?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/fs?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+
+</div>
+
+> Roteamento baseado em convenções de sistema de arquivos para o AsterFlow.
+
+## 📦 Installation
+
+```bash
+# You can use any package manager
+npm install @asterflow/fs
+```
+
+## 💡 About
+
+`@asterflow/fs` brings the convenience of file system-based routing to your AsterFlow projects. Inspired by modern web frameworks, this plugin automatically discovers and registers your routes based on the file and directory structure, allowing you to focus on writing your API logic instead of manual route configuration.
+
+## ✨ Features
+
+  - **Convention over Configuration:** Automatically generates API routes from your file structure.
+  - **Dynamic Parameters:** Support for dynamic segments in filenames (e.g., `$id.ts`).
+  - **Index Routes:** `index.ts` files are treated as the base route of a directory.
+  - **Type-Safe:** Fully integrated with AsterFlow's type system.
+  - **Seamless Integration:** Automatically registers all discovered routes before the server starts.
+
+## 🚀 Usage
+
+### 1\. Project Structure
+
+Create a directory to store your route files. By convention, this directory is usually `routes/` or `src/routes/`.
+
+```
+.
+├── routes/
+│   ├── index.ts          # Handles GET /
+│   ├── users/
+│   │   ├── index.ts      # Handles GET /users
+│   │   └── $id.ts        # Handles GET /users/:id
+├── src
+│   └── index.ts          # Your main application file
+└── package.json
+```
+
+### 2\. Define Your Routes
+
+Each route file must have a `default export` of an AsterFlow `Method` or `Router`.
+
+**`src/routes/users/$id.ts`**
+
+```typescript
+import { Method } from '@asterflow/router';
+
+export default new Method({
+  // The 'path' property will be overwritten by the plugin,
+  // but can be useful for isolated testing.
+  path: '/',
+  method: 'get',
+  handler({ response, url }) {
+    // 'id' will be available at runtime
+    const params = url.getParams();
+    return response.success({ user: { id: params.id } });
+  }
+});
+```
+
+### 3\. Register the Plugin
+
+In your main application file, import and register the `fsRouting` plugin.
+
+**`src/index.ts`**
+
+```typescript
+import { AsterFlow } from '@asterflow/core';
+import { fsRouting } from '@asterflow/fs';
+import { join } from 'path';
+
+// Register the plugin and point it to your routes directory
+export const app = new AsterFlow();
+  .use(fsRouting, {
+    path: join(process.cwd(), 'src', 'routes')
+  });
+
+// Start the server
+app.listen({ port: 3333 }, () => {
+  console.log('Server running with file system routing!');
+});
+```
+
+That's it\! The plugin will scan the `src/routes` directory and register all valid route files when the application starts.
+
+## 🗺️ Routing Conventions
+
+The plugin transforms file paths into URL routes based on the following rules:
+
+| File Path | Generated Route |
+| ----------------- | ------------------ |
+| `index.ts` | `/` |
+| `users.ts` | `/users` |
+| `users/index.ts` | `/users` |
+| `$id.ts` | `/:id` |
+| `products/$id.ts` | `/products/:id` |
+| `categories/$categoryId/products/$productId.ts` | `/categories/:categoryId/products/:productId` |
+
+  - Files named `index` become the root of their directory.
+  - Filenames prefixed with `$` (e.g., `$id.ts`) are converted to dynamic URL parameters (e.g., `/:id`).
+
+## 🔗 Related Packages
+
+  - [@asterflow/core](https://www.npmjs.com/package/@asterflow/core) - The core of the AsterFlow framework.
+  - [@asterflow/plugin](https://www.npmjs.com/package/@asterflow/plugin) - The main plugin system.
+  - [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - The type-safe routing system used by this plugin.
+
+## 📄 License
+
+MIT - See the main project [LICENSE](https://github.com/AsterFlow/AsterFlow/blob/main/LICENSE) for more details.

package/cjs/index.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var a = Object.defineProperty;
+var h = Object.getOwnPropertyDescriptor;
+var x = Object.getOwnPropertyNames;
+var w = Object.prototype.hasOwnProperty;
+var A = (t, e) => {
+  for (var i in e)
+    a(t, i, { get: e[i], enumerable: !0 });
+}, v = (t, e, i, r) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let s of x(e))
+      !w.call(t, s) && s !== i && a(t, s, { get: () => e[s], enumerable: !(r = h(e, s)) || r.enumerable });
+  return t;
+};
+var j = (t) => v(a({}, "__esModule", { value: !0 }), t);
+
+// plugins/fs/src/index.ts
+var b = {};
+A(b, {
+  default: () => P,
+  fsRoutingPlugin: () => y,
+  getFilesRecursively: () => o,
+  transformPathToUrl: () => p
+});
+module.exports = j(b);
+var d = require("@asterflow/plugin"), n = require("@asterflow/router"), g = require("@asterflow/url-parser");
+
+// plugins/fs/package.json
+var u = "1.0.1";
+
+// plugins/fs/src/utils/format.ts
+var c = require("path");
+function p(t, e) {
+  let r = (0, c.relative)(e, t).replace(/\.(ts|js)$/, "");
+  return r.endsWith("/index") ? r = r.slice(0, -6) : r === "index" && (r = ""), r = r.replace(/\$/g, ":"), `/${r}`;
+}
+
+// plugins/fs/src/utils/glob.ts
+var f = require("fs/promises"), m = require("path");
+async function o(t) {
+  let e = await (0, f.readdir)(t, { withFileTypes: !0 });
+  return (await Promise.all(
+    e.map(async (r) => {
+      let s = (0, m.join)(t, r.name);
+      return r.isDirectory() ? o(s) : s;
+    })
+  )).flat();
+}
+
+// plugins/fs/src/index.ts
+var y = d.Plugin.instance().create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", u).config({ path: "" }).derive("files", async (t) => await o(t.path)).extends((t) => ({
+  async registerRoutes(e) {
+    if (e.files.length !== 0)
+      for (let i of e.files) {
+        let s = (await import(i)).default;
+        if (!s || !(s instanceof n.Method || s instanceof n.Router)) continue;
+        let l = p(i, e.path);
+        s.path = l, s.url = new g.Analyze(l), t.controller(s);
+      }
+  }
+})).on("beforeInitialize", async (t, e) => await t.registerRoutes(e)), P = y;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fsRoutingPlugin,
+  getFilesRecursively,
+  transformPathToUrl
+});

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/mjs/index.js

@@ -0,0 +1,46 @@
+// plugins/fs/src/index.ts
+import { Plugin as d } from "@asterflow/plugin";
+import { Method as g, Router as y } from "@asterflow/router";
+import { Analyze as h } from "@asterflow/url-parser";
+
+// plugins/fs/package.json
+var a = "1.0.1";
+
+// plugins/fs/src/utils/format.ts
+import { relative as c } from "path";
+function p(t, r) {
+  let e = c(r, t).replace(/\.(ts|js)$/, "");
+  return e.endsWith("/index") ? e = e.slice(0, -6) : e === "index" && (e = ""), e = e.replace(/\$/g, ":"), `/${e}`;
+}
+
+// plugins/fs/src/utils/glob.ts
+import { readdir as f } from "fs/promises";
+import { join as m } from "path";
+async function o(t) {
+  let r = await f(t, { withFileTypes: !0 });
+  return (await Promise.all(
+    r.map(async (e) => {
+      let s = m(t, e.name);
+      return e.isDirectory() ? o(s) : s;
+    })
+  )).flat();
+}
+
+// plugins/fs/src/index.ts
+var x = d.instance().create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", a).config({ path: "" }).derive("files", async (t) => await o(t.path)).extends((t) => ({
+  async registerRoutes(r) {
+    if (r.files.length !== 0)
+      for (let i of r.files) {
+        let s = (await import(i)).default;
+        if (!s || !(s instanceof g || s instanceof y)) continue;
+        let n = p(i, r.path);
+        s.path = n, s.url = new h(n), t.controller(s);
+      }
+  }
+})).on("beforeInitialize", async (t, r) => await t.registerRoutes(r)), D = x;
+export {
+  D as default,
+  x as fsRoutingPlugin,
+  o as getFilesRecursively,
+  p as transformPathToUrl
+};

package/mjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@asterflow/fs",
+  "version": "1.0.1",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/mjs/index.js",
+  "types": "dist/types/index.d.ts",
+  "typings": "dist/types/index.d.ts",
+  "type": "module",
+  "license": "MIT",
+  "author": "Ashu11-A",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AsterFlow/plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AsterFlow/plugins/issues"
+  },
+  "homepage": "https://github.com/AsterFlow/plugins",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@asterflow/core": "^1.0.7",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@asterflow/router": "^1.0.7",
+    "@asterflow/url-parser": "^2.0.1"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext"
+    ],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "paths": {
+      "@asterflow/fs": [
+        "./types"
+      ],
+      "@asterflow/fs/*": [
+        "./types/*"
+      ]
+    },
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": [
+    "types"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts"
+  ]
+}

package/types/index.d.ts

@@ -0,0 +1,53 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { Plugin } from '@asterflow/plugin';
+
+export declare const fsRoutingPlugin: Plugin<"fs-routing", import("@asterflow/core").IAsterflow<import("@asterflow/core").AnyReminist, {}, [
+], import("@asterflow/adapter").Adapter<import("@asterflow/adapter").Runtime.Node>, {}>, {
+	path: string;
+}, {
+	creator: string;
+} & {
+	version: string;
+} & {
+	files: string[];
+}, Omit<{}, Event> & {
+	beforeInitialize: [
+		(instance: import("@asterflow/core").IAsterflow<import("@asterflow/core").AnyReminist, {}, [
+		], import("@asterflow/adapter").Adapter<import("@asterflow/adapter").Runtime.Node>, {}> & {
+			registerRoutes(context: FSRoutingContext): Promise<void>;
+		}, context: {
+			creator: string;
+		} & {
+			version: string;
+		} & {
+			files: string[];
+		} & {
+			path: string;
+		}) => Promise<void>
+	];
+}, {
+	registerRoutes(context: FSRoutingContext): Promise<void>;
+}>;
+/**
+ * Recursively lists files from a starting directory.
+ * @param dirPath The path to the starting directory.
+ * @returns A promise that resolves to an array of file paths.
+ */
+export declare function getFilesRecursively(dirPath: string): Promise<string[]>;
+/**
+ * Transforms a file path into a robustly formatted URL route.
+ */
+export declare function transformPathToUrl(filePath: string, rootDir: string): string;
+export type FSRoutingContext = {
+	path: string;
+	files: string[];
+	creator: string;
+	version: string;
+};
+
+export {
+	fsRoutingPlugin as default,
+};
+
+export {};