maro-plugin-http 1.1.0

package/README.md

@@ -0,0 +1,15 @@
+# 📡 maro-plugin-http
+
+Hace hablar a las APIs y desvela su esencia.
+
+Con este plugin, Maro puede generar automáticamente documentación Swagger y colecciones Postman a partir de archivos `.http`, convirtiendo especificación en exploración instantánea.
+
+Descubre, documenta y prueba tus endpoints sin salir de la brújula del terminal.
+
+---
+**Comandos principales**
+- Generar documentación Swagger desde archivos `.http`.
+- Crear colecciones Postman listas para testear.
+- Traducir tus flujos de API en puentes tangibles para equipos y automatizaciones.
+
+Conéctate sin fricción con el plano invisible de tus servicios web.

package/dist/src/actions/generate_swagger.d.ts

@@ -0,0 +1,5 @@
+import { Action, MrCreateEvent } from "@maro/maro";
+export declare class GenerateSwagger implements Action {
+    register(): void;
+    execute(event: MrCreateEvent): Promise<void>;
+}

package/dist/src/actions/generate_swagger.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateSwagger = void 0;
+const maro_1 = require("@maro/maro");
+const swagger_1 = require("../lib/swagger");
+const GetHttpFile_1 = require("../steps/GetHttpFile");
+class GenerateSwagger {
+    register() {
+        maro_1.ActionRegistry.on(maro_1.MrCreateEvent, (event) => this.execute(event));
+    }
+    async execute(event) {
+        const repo = event.ctx;
+        if (!maro_1.AppRepo.isAppRepo(repo.dir))
+            return;
+        const paths = (0, maro_1.getPaths)("backend");
+        if (paths.every((p) => p.path !== repo.dir.path))
+            return;
+        const app_repo = new maro_1.AppRepo(repo.dir);
+        const ctx = maro_1.ExecutionContext.get();
+        const { http_file } = await new GetHttpFile_1.GetHttpFile().run(ctx, { app_repo });
+        if (!http_file)
+            return;
+        const file = new swagger_1.Swagger(http_file, app_repo).generate();
+        await repo.add(file);
+        await repo.commit("fix: add swagger");
+    }
+}
+exports.GenerateSwagger = GenerateSwagger;
+__decorate([
+    (0, maro_1.loading)("Generating swagger")
+], GenerateSwagger.prototype, "execute", null);

package/dist/src/commands/postman.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "@maro/maro";
+export declare const PostmanCommand: Command;

package/dist/src/commands/postman.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostmanCommand = void 0;
+const maro_1 = require("@maro/maro");
+const http_file_1 = require("../lib/http_file");
+const postman_1 = require("../lib/postman");
+const types_1 = require("../lib/postman/types");
+exports.PostmanCommand = {
+    name: "postman",
+    description: "Generate postman from http files",
+    run: async ({ ctx, config }) => {
+        const log = ctx.logger;
+        await new maro_1.ValidateConfig({ keys: ["http.collection"] }).run();
+        const collection = new maro_1.Dir(config.get("http.collection"));
+        const collections = collection.readFiles();
+        const files = collections.map((n) => new http_file_1.HttpFile(n.path));
+        const postman = new postman_1.Postman();
+        postman.addFiles(...files);
+        const today = new Date();
+        const day = today.getDate().toString().padStart(2, "0");
+        const month = (today.getMonth() + 1).toString().padStart(2, "0");
+        const year = today.getFullYear();
+        const date = `${year}-${month}-${day}`;
+        // TODO: support other envs and internal/external
+        const name = `Apoderados cert external ${date}.postman_collection`;
+        const file_name = `${name}.json`;
+        const content = postman.generate(name);
+        const postman_dir = collection.getRelative(config.get("http.postman_dir"));
+        const file = new types_1.PostmanFile(postman_dir.createFile(file_name).path);
+        file.write(content);
+        log.success(`${file} generated`);
+    }
+};

package/dist/src/commands/swagger.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "@maro/maro";
+export declare const SwaggerCommand: Command;

package/dist/src/commands/swagger.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerCommand = void 0;
+const maro_1 = require("@maro/maro");
+const swagger_1 = require("../lib/swagger");
+const PromptHttpFile_1 = require("../steps/PromptHttpFile");
+exports.SwaggerCommand = {
+    name: "swagger",
+    description: "Generate swagger from an http file",
+    run: async ({ ctx }) => {
+        const log = ctx.logger;
+        const { http_file } = await new PromptHttpFile_1.PromptHttpFile().run(ctx);
+        const app_name = http_file.service;
+        const { app_repo } = await new maro_1.GetAppRepo().run(ctx, { app_name });
+        const swagger = new swagger_1.Swagger(http_file, app_repo);
+        const file = swagger.generate();
+        log.success(`${file} generated`);
+    }
+};

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginExport } from "@maro/maro";
+declare const Plugin: PluginExport;
+export default Plugin;

package/dist/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const maro_1 = require("@maro/maro");
+const generate_swagger_1 = require("./actions/generate_swagger");
+const postman_1 = require("./commands/postman");
+const swagger_1 = require("./commands/swagger");
+const config_1 = require("./lib/config");
+const Plugin = {
+    name: "maro-plugin-http",
+    onLoad() {
+        maro_1.ConfigRegistry.register(new config_1.HttpConfig());
+        if (maro_1.Config.getView().get("http.generate_swagger"))
+            new generate_swagger_1.GenerateSwagger().register();
+    },
+    commands: [
+        {
+            name: "http",
+            description: "Generate postman collections and swagger from .http files",
+            subcommands: [
+                swagger_1.SwaggerCommand,
+                postman_1.PostmanCommand
+            ]
+        }
+    ]
+};
+exports.default = Plugin;

package/dist/src/lib/config.d.ts

@@ -0,0 +1,12 @@
+import { ConfigHelp, ConfigSection } from "@maro/maro";
+export declare class HttpConfig implements ConfigSection {
+    key: string;
+    validate(config: unknown): {
+        url_suffix?: string | undefined;
+        collection?: string | undefined;
+        postman_dir?: string | undefined;
+        generate_swagger?: boolean | undefined;
+    };
+    help(): ConfigHelp[];
+    setup(): Promise<{}>;
+}

package/dist/src/lib/config.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpConfig = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+const schema = v4_1.default.object({
+    url_suffix: v4_1.default.string().optional(),
+    collection: v4_1.default.string().optional(),
+    postman_dir: v4_1.default.string().optional(),
+    generate_swagger: v4_1.default.boolean().optional()
+});
+class HttpConfig {
+    constructor() {
+        this.key = "http";
+    }
+    validate(config) {
+        if (!config)
+            return {};
+        return schema.parse(config);
+    }
+    help() {
+        return [
+            { key: "url_suffix", description: "Suffix used to extract service name from host variable", type: "string" },
+            { key: "collection", description: "Directory containing HTTP collection files", type: "string" },
+            { key: "postman_dir", description: "Directory to save postman files relative to 'collection'", type: "string" },
+            { key: "generate_swagger", description: "Generate swagger on every AppRepo mr", type: "boolean" }
+        ];
+    }
+    async setup() {
+        return {};
+    }
+}
+exports.HttpConfig = HttpConfig;

package/dist/src/lib/formatter.d.ts

@@ -0,0 +1,23 @@
+import { FileFormatter } from "@maro/maro";
+export declare const valid_methods: readonly ["GET", "PUT", "POST", "PATCH", "DELETE"];
+export type HttpMethod = typeof valid_methods[number];
+export interface ReqObj {
+    method: HttpMethod;
+    params: Record<string, string | null> | null;
+    pathname: string;
+    headers: Record<string, string | null> | null;
+    body: string;
+}
+export type HttpFileContent = {
+    requests: ReqObj[];
+    variables: Record<string, string>;
+};
+export declare class HttpFormatter extends FileFormatter<HttpFileContent> {
+    toString(_input: HttpFileContent): string;
+    fromString(content: string): HttpFileContent;
+    private parseRequests;
+    private getVariable;
+    private getHeader;
+    private getVariables;
+    exception(path: string): Error | void;
+}

package/dist/src/lib/formatter.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpFormatter = exports.valid_methods = void 0;
+const maro_1 = require("@maro/maro");
+const http_file_1 = require("./http_file");
+exports.valid_methods = [
+    "GET",
+    "PUT",
+    "POST",
+    "PATCH",
+    "DELETE"
+];
+class HttpFormatter extends maro_1.FileFormatter {
+    constructor() {
+        super(...arguments);
+        this.getVariable = (l) => {
+            const line = l.replaceAll("#", "").replaceAll(" ", "");
+            if (!line.startsWith("@"))
+                return null;
+            const split = line.split("=");
+            return { key: split?.[0]?.substring(1).trim(), value: split?.[1]?.trim() ?? null };
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toString(_input) {
+        // TODO: implement Writing http files
+        throw new Error("Writing http files is not implemented yet");
+    }
+    fromString(content) {
+        const [globals, ...requestsString] = content.split("###");
+        const variables = this.getVariables(globals ?? "");
+        const requests = this.parseRequests(requestsString);
+        return { requests, variables };
+    }
+    parseRequests(requests) {
+        return requests.map((r) => {
+            if (r.trim() === "")
+                return null;
+            const lines = r.trim().split("\n");
+            const method = lines?.[0]?.split(" ")[0];
+            if (!method || !exports.valid_methods.includes(method))
+                return null;
+            let url = lines?.[0]?.split(" ")[1] ?? "";
+            let i = 1;
+            for (i; i < lines.length; i++) {
+                const l = lines?.[i]?.trim();
+                if (!l || l === "" || !l.startsWith("?") && !l.startsWith("&"))
+                    break;
+                url = url?.concat(l);
+            }
+            const [path, searchParams] = url.split("?");
+            const pathname = `/${path?.split("/").slice(3).join("/") ?? ""}`;
+            const urlSearchParams = new URLSearchParams(searchParams);
+            const params = urlSearchParams && urlSearchParams.size > 0
+                ? Object.fromEntries(Object.entries(Object.fromEntries(urlSearchParams.entries()))) : null;
+            let headers = null;
+            for (i; i < lines.length; i++) {
+                const l = lines[i];
+                if (!l || l.trim() === "")
+                    break;
+                if (!headers)
+                    headers = {};
+                const h = this.getHeader(l);
+                if (!h)
+                    continue;
+                const { key, value } = h;
+                if (key && value)
+                    headers[key] = value;
+            }
+            let bodyString = "";
+            for (i; i < lines.length; i++) {
+                const l = lines[i];
+                if (!l)
+                    continue;
+                bodyString = bodyString.concat(l);
+            }
+            return { method: method, params, pathname, headers, body: bodyString };
+        }).filter((e) => e !== null);
+    }
+    getHeader(l) {
+        const split = l.split(":");
+        if (split.length <= 1)
+            return null;
+        return { key: split[0], value: split?.[1]?.trim() };
+    }
+    getVariables(globals) {
+        const line_filter = (l) => l !== "" && l !== "###" && !l.includes("localhost") && l !== "\n";
+        return Object.fromEntries(globals.split("\n")
+            .filter(line_filter)
+            .map((l) => {
+            const variable = this.getVariable(l);
+            if (!variable?.key || !variable.value)
+                return [];
+            return [variable.key, variable.value];
+        }));
+    }
+    exception(path) {
+        return new http_file_1.InvalidHttpFile(path);
+    }
+}
+exports.HttpFormatter = HttpFormatter;

package/dist/src/lib/http_file.d.ts

@@ -0,0 +1,12 @@
+import { ObjectFile } from "@maro/maro";
+import { HttpFileContent } from "./formatter";
+import { Req } from "./req";
+export declare class HttpFile extends ObjectFile<HttpFileContent> {
+    service: string;
+    constructor(file_path: string);
+    getVariables(): Record<string, string>;
+    getRequests(): Req[];
+}
+export declare class InvalidHttpFile extends Error {
+    constructor(file_path: string, reason?: string);
+}

package/dist/src/lib/http_file.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidHttpFile = exports.HttpFile = void 0;
+const maro_1 = require("@maro/maro");
+const formatter_1 = require("./formatter");
+const req_1 = require("./req");
+class HttpFile extends maro_1.ObjectFile {
+    constructor(file_path) {
+        super(file_path, new formatter_1.HttpFormatter());
+        const url_suffix = maro_1.Config.getView().get("http.url_suffix");
+        if (!url_suffix)
+            throw new maro_1.ConfigError("http.url_suffix");
+        // TODO: I hate the idea of having http files linked to a particular service, find a better way
+        const service = this.getVariables().host?.split(`-${url_suffix}`)?.[0];
+        if (!service)
+            throw new InvalidHttpFile(file_path, "Could not find host variable to determine service name");
+        this.service = service;
+    }
+    getVariables() {
+        return this.read().variables;
+    }
+    getRequests() {
+        return this.read().requests.map((r) => new req_1.Req(r));
+    }
+}
+exports.HttpFile = HttpFile;
+class InvalidHttpFile extends Error {
+    constructor(file_path, reason = "") {
+        super(`Invalid http file ${file_path} ${reason}`);
+    }
+}
+exports.InvalidHttpFile = InvalidHttpFile;

package/dist/src/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { HttpMethod, valid_methods } from "./formatter";
+export { HttpFile } from "./http_file";
+export { Req } from "./req";
+export { GetHttpFile } from "../steps/GetHttpFile";
+export { PromptHttpFile } from "../steps/PromptHttpFile";
+export { PromptHttpFileRequest } from "../steps/PromptHttpFileRequest";

package/dist/src/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptHttpFileRequest = exports.PromptHttpFile = exports.GetHttpFile = exports.Req = exports.HttpFile = exports.valid_methods = void 0;
+var formatter_1 = require("./formatter");
+Object.defineProperty(exports, "valid_methods", { enumerable: true, get: function () { return formatter_1.valid_methods; } });
+var http_file_1 = require("./http_file");
+Object.defineProperty(exports, "HttpFile", { enumerable: true, get: function () { return http_file_1.HttpFile; } });
+var req_1 = require("./req");
+Object.defineProperty(exports, "Req", { enumerable: true, get: function () { return req_1.Req; } });
+var GetHttpFile_1 = require("../steps/GetHttpFile");
+Object.defineProperty(exports, "GetHttpFile", { enumerable: true, get: function () { return GetHttpFile_1.GetHttpFile; } });
+var PromptHttpFile_1 = require("../steps/PromptHttpFile");
+Object.defineProperty(exports, "PromptHttpFile", { enumerable: true, get: function () { return PromptHttpFile_1.PromptHttpFile; } });
+var PromptHttpFileRequest_1 = require("../steps/PromptHttpFileRequest");
+Object.defineProperty(exports, "PromptHttpFileRequest", { enumerable: true, get: function () { return PromptHttpFileRequest_1.PromptHttpFileRequest; } });

package/dist/src/lib/postman/body.d.ts

@@ -0,0 +1,11 @@
+import { Req } from "../req";
+import { PostmanRequestBody } from "./types";
+interface BodyStrategy {
+    supports(req: Req): boolean;
+    createBody(req: Req): any;
+}
+export declare class JsonBodyStrategy implements BodyStrategy {
+    supports(req: Req): boolean;
+    createBody(req: Req): PostmanRequestBody;
+}
+export {};

package/dist/src/lib/postman/body.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonBodyStrategy = void 0;
+class JsonBodyStrategy {
+    supports(req) {
+        return Boolean(req.body?.trim() && req.body.includes("{"));
+    }
+    createBody(req) {
+        return {
+            mode: "raw",
+            raw: req.body,
+            options: { raw: { language: "json" } }
+        };
+    }
+}
+exports.JsonBodyStrategy = JsonBodyStrategy;

package/dist/src/lib/postman/index.d.ts

@@ -0,0 +1,8 @@
+import { HttpFile } from "../http_file";
+import { PostmanContent } from "./types";
+export declare class Postman {
+    private readonly files;
+    addFiles(...files: HttpFile[]): this;
+    generate(name: string): PostmanContent;
+    private convertFile;
+}

package/dist/src/lib/postman/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Postman = void 0;
+const request_1 = require("./request");
+const schema = "https://schema.getpostman.com/json/collection/v2.1.0/collection.json";
+class Postman {
+    constructor() {
+        this.files = [];
+    }
+    addFiles(...files) {
+        this.files.push(...files);
+        return this;
+    }
+    generate(name) {
+        const items = this.files.map(this.convertFile);
+        return { info: { name, schema }, item: items };
+    }
+    convertFile(file) {
+        return {
+            name: file.service,
+            item: file.getRequests().map((r) => new request_1.PostmanRequestAdapter(r).toPostmanItem())
+        };
+    }
+}
+exports.Postman = Postman;

package/dist/src/lib/postman/request.d.ts

@@ -0,0 +1,10 @@
+import { Req } from "../req";
+import { PostmanRequestItem } from "./types";
+export declare class PostmanRequestAdapter {
+    private readonly req;
+    constructor(req: Req);
+    toPostmanItem(): PostmanRequestItem;
+    private buildUrl;
+    private buildHeaders;
+    private buildBody;
+}

package/dist/src/lib/postman/request.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostmanRequestAdapter = void 0;
+const req_1 = require("../req");
+const body_1 = require("./body");
+class PostmanRequestAdapter {
+    constructor(req) {
+        this.req = req;
+    }
+    toPostmanItem() {
+        const builder = new PostmanRequestBuilder();
+        builder
+            .setName(`${this.req.method.toUpperCase()} ${this.req.pathname}`)
+            .setMethod(this.req.method.toUpperCase())
+            .setUrl(this.buildUrl())
+            .setHeaders(...this.buildHeaders());
+        const body = this.buildBody();
+        if (body)
+            builder.setBody(body);
+        return builder.build();
+    }
+    buildUrl() {
+        const path = this.req.pathname.replace(req_1.varRegex, ":$1");
+        return {
+            raw: path,
+            protocol: "http",
+            host: [path.split("/")[1] || ""],
+            path: path.split("/").slice(2),
+            query: Object.entries(this.req.params ?? {})
+                .filter(([, v]) => v)
+                .map(([key, val]) => ({
+                key,
+                value: val.toString()
+            }))
+        };
+    }
+    buildHeaders() {
+        return Object.entries(this.req.headers ?? {})
+            .filter(([, v]) => v)
+            .map(([key, value]) => ({ key, value })); // we are filtering nulls
+    }
+    buildBody() {
+        // TODO: probably iterate over available strategies
+        // to identify which to use
+        const strategy = new body_1.JsonBodyStrategy();
+        if (strategy.supports(this.req))
+            return strategy.createBody(this.req);
+        return undefined;
+    }
+}
+exports.PostmanRequestAdapter = PostmanRequestAdapter;
+class PostmanRequestBuilder {
+    constructor() {
+        this.item = {};
+    }
+    setName(name) {
+        this.item.name = name;
+        return this;
+    }
+    setMethod(method) {
+        this.item.request ??= { method };
+        this.item.request.method = method;
+        return this;
+    }
+    setUrl(url) {
+        this.item.request ??= { url };
+        this.item.request.url = url;
+        return this;
+    }
+    setHeaders(...header) {
+        this.item.request ??= { header };
+        this.item.request.header = header;
+        return this;
+    }
+    setBody(body) {
+        this.item.request ??= { body };
+        this.item.request.body = body;
+        return this;
+    }
+    build() {
+        // TODO: probably validate this has been properly built
+        return this.item;
+    }
+}

package/dist/src/lib/postman/types.d.ts

@@ -0,0 +1,105 @@
+import { JsonFile } from "@maro/maro";
+export type PostmanContent = {
+    info: PostmanInfo;
+    item: PostmanItem[];
+    event?: PostmanEvent[];
+    variable?: PostmanVariable[];
+};
+type PostmanInfo = {
+    name: string;
+    description?: string;
+    schema: string;
+};
+type PostmanItem = PostmanFolder | PostmanRequestItem;
+export type PostmanFolder = {
+    name: string;
+    description?: string | PostmanDescription;
+    item: PostmanItem[];
+    event?: PostmanEvent[];
+    variable?: PostmanVariable[];
+};
+export type PostmanRequestItem = {
+    name: string;
+    request: PostmanRequest;
+    event?: PostmanEvent[];
+};
+type PostmanRequest = {
+    method?: string;
+    header?: PostmanHeader[];
+    url?: PostmanUrl;
+    body?: PostmanRequestBody;
+    description?: string | PostmanDescription;
+};
+export type PostmanHeader = {
+    key: string;
+    value: string;
+    type?: string;
+    disabled?: boolean;
+};
+export type PostmanUrl = {
+    raw?: string;
+    protocol?: string;
+    host?: string[];
+    path?: string[];
+    port?: string;
+    query?: PostmanQueryParam[];
+    variable?: PostmanVariable[];
+};
+type PostmanQueryParam = {
+    key: string;
+    value?: string;
+    description?: string | PostmanDescription;
+    disabled?: boolean;
+};
+type PostmanVariable = {
+    key: string;
+    value?: any;
+    description?: string | PostmanDescription;
+    type?: string;
+    disabled?: boolean;
+};
+export type PostmanRequestBody = {
+    mode: "raw" | "urlencoded" | "formdata" | "file" | "graphql";
+    raw?: string;
+    graphql?: {
+        query: string;
+        variables?: any;
+    };
+    urlencoded?: PostmanKeyValue[];
+    formdata?: (PostmanKeyValue | PostmanFormDataFile)[];
+    file?: {
+        src?: string;
+    };
+    options?: any;
+};
+type PostmanKeyValue = {
+    key: string;
+    value?: string;
+    type?: string;
+    disabled?: boolean;
+    description?: string | PostmanDescription;
+};
+type PostmanFormDataFile = {
+    key: string;
+    src: string | string[];
+    type: "file";
+    disabled?: boolean;
+    description?: string | PostmanDescription;
+};
+type PostmanEvent = {
+    listen: "test" | "prerequest";
+    script: PostmanScript;
+};
+type PostmanScript = {
+    id?: string;
+    type?: string;
+    exec: string[];
+};
+type PostmanDescription = {
+    content: string;
+    type?: string;
+    version?: string;
+};
+export declare class PostmanFile extends JsonFile<PostmanContent> {
+}
+export {};

package/dist/src/lib/postman/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostmanFile = void 0;
+const maro_1 = require("@maro/maro");
+class PostmanFile extends maro_1.JsonFile {
+}
+exports.PostmanFile = PostmanFile;

package/dist/src/lib/req.d.ts

@@ -0,0 +1,31 @@
+import { Choice } from "@maro/maro";
+import { HttpMethod, ReqObj } from "./formatter";
+export declare const varRegex: RegExp;
+export declare class Req implements ReqObj {
+    method: HttpMethod;
+    params: Record<string, string | null> | null;
+    pathname: string;
+    headers: Record<string, string | null> | null;
+    body: string;
+    variables: Record<string, string>;
+    constructor(reqObj: ReqObj, variables?: {});
+    send(url: string, variables?: Record<string, string>): Promise<{
+        res: import("axios").AxiosResponse<any, any>;
+        config: {
+            method: "GET" | "PUT" | "POST" | "PATCH" | "DELETE";
+            params: {
+                [k: string]: string | undefined;
+            };
+            headers: Record<string, string | null>;
+            url: string;
+            data: any;
+        };
+    }>;
+    replaceVariables(string: string, options?: {
+        quote_strings?: boolean;
+        variables?: Record<string, string | null>;
+    }): string;
+    private replaceableVariables;
+    toString(): string;
+    toChoice(): Choice;
+}

package/dist/src/lib/req.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Req = exports.varRegex = void 0;
+const axios_1 = __importDefault(require("axios"));
+exports.varRegex = /{{(.*?)}}/g;
+class Req {
+    constructor(reqObj, variables = {}) {
+        this.pathname = reqObj.pathname;
+        this.params = reqObj.params;
+        this.method = reqObj.method;
+        this.headers = reqObj.headers;
+        this.body = reqObj.body;
+        this.variables = variables;
+    }
+    async send(url, variables) {
+        const vars = this.replaceableVariables();
+        const replace = variables ? { ...this.variables, ...Object.fromEntries(vars.map((v) => [v, variables[v] ?? null])) } : this.variables;
+        const req_config = {
+            method: this.method,
+            params: Object.fromEntries(Object.entries(this.params ?? {}).map(([k, v]) => [k, v ? this.replaceVariables(v, { variables: replace }) : undefined])),
+            headers: this.headers ?? {},
+            url: `${url}${this.replaceVariables(this.pathname, { variables: replace })}`,
+            data: JSON.parse(this.replaceVariables(this.body, { quote_strings: true, variables: replace }) ?? "{}")
+        };
+        const res = await axios_1.default.request(req_config);
+        return { res, config: req_config };
+    }
+    replaceVariables(string, options) {
+        let res = string;
+        Object.entries({ ...this.variables, ...options?.variables })
+            .forEach(([k, v]) => {
+            const value = options?.quote_strings && typeof v === "string" ? `"${v.replaceAll("\"", "")}"` : v;
+            res = res?.replaceAll(`{{${k}}}`, value ?? "null");
+        });
+        return res;
+    }
+    replaceableVariables() {
+        const res = [];
+        res.push(...Array.from(this.pathname.matchAll(exports.varRegex)).map((m) => m?.[1] ?? ""), ...Array.from(this.body.matchAll(exports.varRegex)).map((m) => m?.[1] ?? ""), ...this.params
+            ? Object.entries(this.params)
+                .flatMap(([, v]) => v ? Array.from(v.matchAll(exports.varRegex)).map((m) => m?.[1] ?? "") : [])
+            : []);
+        return Array.from(new Set(res));
+    }
+    toString() {
+        return `${this.method} ${this.pathname}`;
+    }
+    toChoice() {
+        return { name: this.toString() };
+    }
+}
+exports.Req = Req;

package/dist/src/lib/swagger/file.d.ts

@@ -0,0 +1,72 @@
+import { YamlFile } from "@maro/maro";
+export type SwaggerContent = {
+    openapi: string;
+    info: SwaggerInfo;
+    paths: Record<string, SwaggerPathItem>;
+};
+type SwaggerInfo = {
+    title: string;
+    version: string;
+    description?: string;
+};
+export type SwaggerPathItem = {
+    get?: SwaggerOperation;
+    post?: SwaggerOperation;
+    put?: SwaggerOperation;
+    delete?: SwaggerOperation;
+    patch?: SwaggerOperation;
+    options?: SwaggerOperation;
+    head?: SwaggerOperation;
+    trace?: SwaggerOperation;
+    parameters?: SwaggerParameter[];
+};
+export type SwaggerOperation = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    parameters?: SwaggerParameter[];
+    requestBody?: SwaggerRequestBody;
+    responses: Record<string, SwaggerResponse>;
+};
+export type SwaggerParameter = {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    required?: boolean;
+    description?: string;
+    schema?: SwaggerSchema;
+};
+export type SwaggerRequestBody = {
+    description?: string;
+    required?: boolean;
+    content: Record<string, SwaggerMediaType>;
+};
+export type SwaggerResponse = {
+    description: string;
+    headers?: Record<string, SwaggerHeader>;
+    content?: Record<string, SwaggerMediaType>;
+};
+type SwaggerHeader = {
+    description?: string;
+    required?: boolean;
+    schema?: SwaggerSchema;
+};
+type SwaggerMediaType = {
+    schema?: SwaggerSchema;
+    example?: any;
+    examples?: Record<string, any>;
+};
+type SwaggerSchema = {
+    type?: string;
+    format?: string;
+    properties?: Record<string, SwaggerSchema>;
+    items?: SwaggerSchema;
+    required?: string[];
+    enum?: string[];
+    nullable?: boolean;
+    description?: string;
+    default?: any;
+    $ref?: string;
+};
+export declare class SwaggerFile extends YamlFile<SwaggerContent> {
+}
+export {};

package/dist/src/lib/swagger/file.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerFile = void 0;
+const maro_1 = require("@maro/maro");
+class SwaggerFile extends maro_1.YamlFile {
+}
+exports.SwaggerFile = SwaggerFile;

package/dist/src/lib/swagger/index.d.ts

@@ -0,0 +1,9 @@
+import { AppRepo } from "@maro/maro";
+import { HttpFile } from "../http_file";
+import { SwaggerFile } from "./file";
+export declare class Swagger {
+    private readonly file;
+    private readonly app_repo;
+    constructor(file: HttpFile, app_repo: AppRepo);
+    generate(): SwaggerFile;
+}

package/dist/src/lib/swagger/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swagger = void 0;
+const params_1 = require("./params");
+const paths_1 = require("./paths");
+const request_1 = require("./request");
+const file_1 = require("./file");
+class Swagger {
+    constructor(file, app_repo) {
+        this.file = file;
+        this.app_repo = app_repo;
+    }
+    generate() {
+        const { description, version } = this.app_repo.getPackage();
+        const pathsBuilder = new paths_1.SwaggerPaths();
+        for (const req of this.file.getRequests()) {
+            const adapter = new request_1.SwaggerRequestAdapter(req, new params_1.RegexParamExtractionStrategy());
+            pathsBuilder.add(adapter.toSwaggerItem());
+        }
+        const content = {
+            openapi: "3.0.2",
+            info: {
+                title: this.file.service,
+                description,
+                version
+            },
+            paths: pathsBuilder.build()
+        };
+        const file = this.app_repo.dir.sub("swagger").sub("docs").createFile("specification.yaml");
+        const swagger = new file_1.SwaggerFile(file.path);
+        swagger.write(content);
+        return swagger;
+    }
+}
+exports.Swagger = Swagger;

package/dist/src/lib/swagger/operation.d.ts

@@ -0,0 +1,11 @@
+import { SwaggerOperation } from "./file";
+export declare class SwaggerOperationBuilder {
+    private parameters;
+    private requestBody?;
+    private responses;
+    withPathParams(names: string[]): this;
+    withQueryParams(names: string[]): this;
+    withJsonRequestBody(): this;
+    withDefaultResponses(): this;
+    build(): SwaggerOperation;
+}

package/dist/src/lib/swagger/operation.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerOperationBuilder = void 0;
+class SwaggerOperationBuilder {
+    constructor() {
+        this.parameters = [];
+        this.responses = {};
+    }
+    withPathParams(names) {
+        this.parameters.push(...names.map((name) => ({
+            name,
+            in: "path",
+            required: true,
+            schema: { type: "string" }
+        })));
+        return this;
+    }
+    withQueryParams(names) {
+        this.parameters.push(...names.map((name) => ({
+            name,
+            in: "query",
+            required: false,
+            schema: { type: "string" }
+        })));
+        return this;
+    }
+    withJsonRequestBody() {
+        this.requestBody = {
+            content: {
+                "application/json": {
+                    schema: {
+                        type: "object"
+                    }
+                }
+            }
+        };
+        return this;
+    }
+    withDefaultResponses() {
+        this.responses = {
+            200: { description: "OK" },
+            400: { description: "BAD_REQUEST" },
+            500: { description: "INTERNAL_SERVER_ERROR" }
+        };
+        return this;
+    }
+    build() {
+        const operation = {
+            parameters: this.parameters,
+            responses: this.responses
+        };
+        if (this.requestBody) {
+            operation.requestBody = this.requestBody;
+        }
+        return operation;
+    }
+}
+exports.SwaggerOperationBuilder = SwaggerOperationBuilder;

package/dist/src/lib/swagger/params.d.ts

@@ -0,0 +1,11 @@
+import { Req } from "../req";
+export interface ExtractedParams {
+    pathParams: string[];
+    queryParams: string[];
+}
+export interface ParamExtractionStrategy {
+    extract(req: Req): ExtractedParams;
+}
+export declare class RegexParamExtractionStrategy implements ParamExtractionStrategy {
+    extract(req: Req): ExtractedParams;
+}

package/dist/src/lib/swagger/params.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexParamExtractionStrategy = void 0;
+const req_1 = require("../req");
+class RegexParamExtractionStrategy {
+    extract(req) {
+        const pathParams = Array.from(req.pathname.matchAll(req_1.varRegex)).map((m) => m[1]).filter((p) => Boolean(p));
+        const queryParams = Object.entries(req.params ?? {})
+            .flatMap(([key, value]) => {
+            if (!value)
+                return [];
+            return value.match(req_1.varRegex) ? [key] : [];
+        });
+        return { pathParams, queryParams };
+    }
+}
+exports.RegexParamExtractionStrategy = RegexParamExtractionStrategy;

package/dist/src/lib/swagger/paths.d.ts

@@ -0,0 +1,6 @@
+import { SwaggerPathItem } from "./file";
+export declare class SwaggerPaths {
+    private paths;
+    add(fragment: SwaggerPathItem): void;
+    build(): Record<string, SwaggerPathItem>;
+}

package/dist/src/lib/swagger/paths.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerPaths = void 0;
+class SwaggerPaths {
+    constructor() {
+        this.paths = {};
+    }
+    add(fragment) {
+        for (const [path, methods] of Object.entries(fragment)) {
+            this.paths[path] ??= {};
+            Object.assign(this.paths[path], methods);
+        }
+    }
+    build() {
+        return this.paths;
+    }
+}
+exports.SwaggerPaths = SwaggerPaths;

package/dist/src/lib/swagger/request.d.ts

@@ -0,0 +1,9 @@
+import { Req } from "../req";
+import { SwaggerPathItem } from "./file";
+import { ParamExtractionStrategy } from "./params";
+export declare class SwaggerRequestAdapter {
+    private req;
+    private readonly paramStrategy;
+    constructor(req: Req, paramStrategy: ParamExtractionStrategy);
+    toSwaggerItem(): SwaggerPathItem;
+}

package/dist/src/lib/swagger/request.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerRequestAdapter = void 0;
+const req_1 = require("../req");
+const operation_1 = require("./operation");
+class SwaggerRequestAdapter {
+    constructor(req, paramStrategy) {
+        this.req = req;
+        this.paramStrategy = paramStrategy;
+    }
+    toSwaggerItem() {
+        const path = this.req.pathname.replace(req_1.varRegex, "{$1}");
+        const { pathParams, queryParams } = this.paramStrategy.extract(this.req);
+        const builder = new operation_1.SwaggerOperationBuilder()
+            .withPathParams(pathParams)
+            .withQueryParams(queryParams)
+            .withDefaultResponses();
+        if (this.req.body && this.req.body.trim() !== "{}") {
+            builder.withJsonRequestBody();
+        }
+        return {
+            [path]: {
+                [this.req.method.toLowerCase()]: builder.build()
+            }
+        };
+    }
+}
+exports.SwaggerRequestAdapter = SwaggerRequestAdapter;

package/dist/src/steps/GetHttpFile.d.ts

@@ -0,0 +1,17 @@
+import { AppRepo, ExecutionContext, WorkflowStep } from "@maro/maro";
+import { HttpFile } from "../lib/http_file";
+type Reads = {
+    app_repo: AppRepo;
+};
+type Writes = {
+    http_file?: HttpFile;
+};
+type Options = {};
+export declare class GetHttpFile extends WorkflowStep<Reads, Writes, Options> {
+    run(ctx: ExecutionContext, { app_repo }: Reads): Promise<{
+        http_file?: undefined;
+    } | {
+        http_file: HttpFile;
+    }>;
+}
+export {};

package/dist/src/steps/GetHttpFile.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHttpFile = void 0;
+const maro_1 = require("@maro/maro");
+const http_file_1 = require("../lib/http_file");
+class GetHttpFile extends maro_1.WorkflowStep {
+    async run(ctx, { app_repo }) {
+        const log = ctx.logger;
+        new maro_1.ValidateConfig({ keys: ["http.collection"] }).run();
+        const collection = maro_1.Config.getView().get("http.collection");
+        const collections = new maro_1.Dir(collection).readFiles();
+        const files = collections.map((n) => new http_file_1.HttpFile(n.path));
+        const { name } = await app_repo.getInfo();
+        const http_file = files.find((f) => f.service === name);
+        if (!http_file) {
+            log.error(`Could not find http_file for app ${name}`);
+            return {};
+        }
+        return { http_file };
+    }
+}
+exports.GetHttpFile = GetHttpFile;

package/dist/src/steps/PromptHttpFile.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContext, WorkflowStep } from "@maro/maro";
+import { HttpFile } from "../lib/http_file";
+type Reads = {};
+type Writes = {
+    http_file: HttpFile;
+};
+type Options = {};
+export declare class PromptHttpFile extends WorkflowStep<Reads, Writes, Options> {
+    run(ctx: ExecutionContext): Promise<{
+        http_file: HttpFile;
+    }>;
+}
+export {};

package/dist/src/steps/PromptHttpFile.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptHttpFile = void 0;
+const maro_1 = require("@maro/maro");
+const http_file_1 = require("../lib/http_file");
+class PromptHttpFile extends maro_1.WorkflowStep {
+    async run(ctx) {
+        await new maro_1.ValidateConfig({ keys: ["http.collection"] }).run();
+        const config = maro_1.Config.getView();
+        const collection = new maro_1.Dir(config.get("http.collection"));
+        const collections = collection.readFiles();
+        const files = collections.map((n) => new http_file_1.HttpFile(n.path));
+        const http_file = await ctx.ui.promptChoice(files);
+        return { http_file };
+    }
+}
+exports.PromptHttpFile = PromptHttpFile;

package/dist/src/steps/PromptHttpFileRequest.d.ts

@@ -0,0 +1,20 @@
+import { ExecutionContext, WorkflowOptions, WorkflowStep } from "@maro/maro";
+import { HttpFile } from "../lib/http_file";
+import { Req } from "../lib/req";
+type Reads = {
+    http_file: HttpFile;
+};
+type Writes<Multiple> = Multiple extends true ? {
+    requests: Req[];
+} : {
+    request: Req;
+};
+type Options<Multiple> = {
+    multiple?: Multiple;
+};
+export declare class PromptHttpFileRequest<Multiple extends boolean = false> extends WorkflowStep<Reads, Writes<Multiple>, Options<Multiple>> {
+    options?: WorkflowOptions<Options<Multiple>, Writes<Multiple>> | undefined;
+    constructor(options?: WorkflowOptions<Options<Multiple>, Writes<Multiple>> | undefined);
+    run(ctx: ExecutionContext, { http_file }: Reads): Promise<Writes<Multiple>>;
+}
+export {};

package/dist/src/steps/PromptHttpFileRequest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptHttpFileRequest = void 0;
+const maro_1 = require("@maro/maro");
+class PromptHttpFileRequest extends maro_1.WorkflowStep {
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    async run(ctx, { http_file }) {
+        const multiple = this.options?.multiple;
+        const requests = http_file.getRequests()
+            .filter((r) => r.pathname !== "/health");
+        const service = http_file.service;
+        const services = await ctx.ui.promptChoice(requests, {
+            multiple,
+            message: `Choose request for ${service}`
+        });
+        if (Array.isArray(services))
+            return { requests: services };
+        return { request: services };
+    }
+}
+exports.PromptHttpFileRequest = PromptHttpFileRequest;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "maro-plugin-http",
+  "version": "1.1.0",
+  "main": "./dist/src/lib/index.js",
+  "types": "./dist/src/lib/index.d.ts",
+  "type": "commonjs",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsc --project ./tsconfig.json",
+    "start": "node ./dist/src/index.js",
+    "clean": "rm -rf node_modules package-lock.json",
+    "import": "npm run clean; cp ../../maro/maro-2.0.0.tgz ./maro-2.0.0.tgz; npm install"
+  },
+  "maro": {
+    "plugin": "./dist/src/index.js"
+  },
+  "dependencies": {
+    "zod": "3.25.57"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@stylistic/eslint-plugin": "2.6.5",
+    "eslint": "8.57.1",
+    "eslint-plugin-de-morgan": "2.0.0",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-math": "0.13.1",
+    "eslint-plugin-promise": "7.2.1",
+    "eslint-plugin-unused-imports": "4.3.0"
+  }
+}