bytekit 1.0.20 → 1.0.22

package/bin/{sutils.js → bytekit.js}

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 import { runCli } from "../dist/cli/index.js";
 
-try {
-    await runCli(process.argv.slice(2));
-} catch (error) {
+runCli(process.argv.slice(2)).catch((error) => {
     console.error(error);
     process.exit(1);
-}
+});

package/dist/cli/index.d.ts

@@ -1,2 +1,5 @@
+/**
+ * Main CLI entry point for bytekit
+ */
 export declare function runCli(argv: string[]): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAyBA,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB1D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuE1D"}

package/dist/cli/index.js

@@ -2,502 +2,132 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { generateTypesFromEndpoint } from "./type-generator.js";
-const DEFAULT_API_DIR = "api";
-const DEFAULT_HOOKS_DIR = "hooks";
+import { generateFromSwagger } from "./swagger-generator.js";
+/**
+ * Main CLI entry point for bytekit
+ */
 export async function runCli(argv) {
-    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
         printHelp();
         return;
     }
-    const [command, target, ...rest] = argv;
-    if (command === "create") {
-        await handleCreate(target, rest);
-    }
-    else if (command === "types") {
-        await handleTypes(target, rest);
-    }
-    else {
-        console.error(`\u001b[31mUnknown command:\u001b[0m ${command}`);
-        printHelp();
-        process.exit(1);
-    }
-}
-async function handleCreate(resource, args) {
-    if (!resource || resource.startsWith("--")) {
-        console.error("\u001b[31mMissing resource name.\u001b[0m");
-        printCreateHelp();
-        process.exit(1);
-    }
-    const flags = parseCreateFlags(args);
-    const resourceSegments = resource.split("/").filter(Boolean);
-    if (resourceSegments.length === 0) {
-        console.error("\u001b[31mResource name cannot be empty.\u001b[0m");
-        process.exit(1);
-    }
-    const config = {
-        apiDir: flags.apiDir ?? DEFAULT_API_DIR,
-        hooksDir: flags.hooksDir ?? DEFAULT_HOOKS_DIR,
-        force: Boolean(flags.force),
-        route: flags.route ?? `/${resourceSegments.join("/")}`,
-        resourceSegments,
-        queryLib: flags.queryLib ?? "react-query",
+    const options = {
+        method: "GET",
+        headers: {},
     };
-    await createResourceFiles(config);
-}
-async function handleTypes(endpoint, args) {
-    if (!endpoint) {
-        console.error("\u001b[31mMissing endpoint URL.\u001b[0m");
-        printTypesHelp();
-        process.exit(1);
-    }
-    const flags = parseTypesFlags(args);
-    await generateTypesFromEndpoint({
-        endpoint,
-        method: (flags.method ?? "GET"),
-        output: flags.output,
-        name: flags.name,
-        headers: flags.headers,
-    });
-}
-function parseCreateFlags(args) {
-    const flags = {};
-    for (const arg of args) {
-        if (!arg.startsWith("--")) {
-            console.warn(`Ignoring unexpected argument "${arg}".`);
-            continue;
-        }
-        const withoutDashes = arg.slice(2);
-        const [rawKey, rawValue] = withoutDashes.split("=", 2);
-        const key = rawKey.trim();
-        if (key === "force") {
-            flags.force = rawValue === undefined ? true : rawValue === "true";
-            continue;
-        }
-        if (rawValue === undefined) {
-            console.warn(`Flag "--${key}" requires a value; ignoring.`);
-            continue;
+    const VALID_METHODS = [
+        "GET",
+        "POST",
+        "PUT",
+        "PATCH",
+        "DELETE",
+    ];
+    // Simple argument parser
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--type") {
+            options.type = true;
         }
-        switch (key) {
-            case "apiDir":
-                flags.apiDir = rawValue;
-                break;
-            case "hooksDir":
-                flags.hooksDir = rawValue;
-                break;
-            case "route":
-                flags.route = rawValue;
-                break;
-            case "queryLib":
-                if (rawValue === "react-query" || rawValue === "rtk-query") {
-                    flags.queryLib = rawValue;
-                }
-                else {
-                    console.warn(`Invalid queryLib value "${rawValue}". Use "react-query" or "rtk-query".`);
-                }
-                break;
-            default:
-                console.warn(`Unrecognized flag "--${key}"; ignoring.`);
+        else if (arg === "--swagger") {
+            options.swagger = true;
         }
-    }
-    return flags;
-}
-function parseTypesFlags(args) {
-    const flags = { headers: {} };
-    for (const arg of args) {
-        if (!arg.startsWith("--")) {
-            console.warn(`Ignoring unexpected argument "${arg}".`);
-            continue;
+        else if (arg.startsWith("--method=")) {
+            const inputMethod = arg.split("=")[1].toUpperCase();
+            if (VALID_METHODS.includes(inputMethod)) {
+                options.method = inputMethod;
+            }
         }
-        const withoutDashes = arg.slice(2);
-        const [rawKey, rawValue] = withoutDashes.split("=", 2);
-        const key = rawKey.trim();
-        if (rawValue === undefined) {
-            console.warn(`Flag "--${key}" requires a value; ignoring.`);
-            continue;
+        else if (arg.startsWith("--body=")) {
+            options.body = arg.split("=")[1];
         }
-        switch (key) {
-            case "method":
-                flags.method = rawValue.toUpperCase();
-                break;
-            case "output":
-                flags.output = rawValue;
-                break;
-            case "name":
-                flags.name = rawValue;
-                break;
-            case "header": {
-                const [headerKey, headerValue] = rawValue.split(":", 2);
-                if (headerKey && headerValue) {
-                    flags.headers[headerKey.trim()] = headerValue.trim();
-                }
-                break;
+        else if (arg.startsWith("--header=") ||
+            arg.startsWith("--headers=")) {
+            const fullValue = arg.split("=")[1];
+            // Split only on the first colon to support values like "Authorization: Bearer key:123"
+            const firstColonIndex = fullValue.indexOf(":");
+            if (firstColonIndex !== -1) {
+                const key = fullValue.slice(0, firstColonIndex).trim();
+                const value = fullValue.slice(firstColonIndex + 1).trim();
+                options.headers[key] = value;
             }
-            default:
-                console.warn(`Unrecognized flag "--${key}"; ignoring.`);
+        }
+        else if (!arg.startsWith("-")) {
+            options.url = arg;
         }
     }
-    return flags;
-}
-async function createResourceFiles(config) {
-    const { apiDir, hooksDir, force, resourceSegments, route } = config;
-    const lastSegment = resourceSegments.at(-1);
-    const pascalPlural = toPascalCase(lastSegment);
-    const singularSegment = toSingular(lastSegment);
-    const pascalSingular = toPascalCase(singularSegment);
-    const resolvedRoute = route.startsWith("/") ? route : `/${route}`;
-    const resourceKey = resourceSegments.join("/");
-    const apiResourceDir = path.join(process.cwd(), apiDir, ...resourceSegments);
-    const hooksResourceDir = path.join(process.cwd(), hooksDir, ...resourceSegments);
-    await fs.mkdir(apiResourceDir, { recursive: true });
-    await fs.mkdir(hooksResourceDir, { recursive: true });
-    const apiFilePath = path.join(apiResourceDir, "index.ts");
-    const hooksFilePath = path.join(hooksResourceDir, `use${pascalPlural}.ts`);
-    const hooksIndexPath = path.join(hooksResourceDir, "index.ts");
-    const apiImportPath = buildImportPath(hooksResourceDir, apiResourceDir);
-    await writeFileIfAllowed(apiFilePath, buildApiTemplate({
-        pluralPascal: pascalPlural,
-        singularPascal: pascalSingular,
-        route: resolvedRoute,
-    }), force);
-    await writeFileIfAllowed(hooksFilePath, config.queryLib === "rtk-query"
-        ? buildRtkQueryHooksTemplate({
-            pascalPlural,
-            pascalSingular,
-            resourceKey,
-            apiImportPath,
-        })
-        : buildHooksTemplate({
-            pascalPlural,
-            pascalSingular,
-            resourceKey,
-            apiImportPath,
-        }), force);
-    await writeFileIfAllowed(hooksIndexPath, `export * from "./use${pascalPlural}";\n`, force);
-    console.log(`Scaffolded "${resourceKey}" under "${apiDir}" and "${hooksDir}".`);
-}
-function buildImportPath(fromDir, toDir) {
-    const relativePath = path.relative(fromDir, toDir).replace(/\\/g, "/");
-    if (!relativePath.startsWith(".")) {
-        return `./${relativePath}`;
+    if (!options.url) {
+        console.error("\u001b[31mError: Missing URL\u001b[0m");
+        process.exit(1);
     }
-    return relativePath;
-}
-async function writeFileIfAllowed(filePath, content, force) {
-    try {
-        await fs.access(filePath);
-        if (!force) {
-            console.warn(`Skipping existing file: ${filePath}`);
-            return;
-        }
+    if (options.swagger) {
+        await generateFromSwagger({ url: options.url });
     }
-    catch {
-        // file does not exist
+    else if (options.type) {
+        await handleTypeGeneration(options);
+    }
+    else {
+        // Simple fetch/curl behavior if --type is not present
+        await handleSimpleFetch(options);
     }
-    await fs.writeFile(filePath, content, "utf8");
-    console.log(`Generated ${filePath}`);
-}
-function buildApiTemplate(options) {
-    const { pluralPascal, singularPascal, route } = options;
-    return `import type { ApiClient } from "bytekit";
-
-const RESOURCE_PATH = "${route}";
-
-export interface ${singularPascal}Dto {
-    id: string;
-    /** Extend with the fields returned by the API. */
-}
-
-export type Create${singularPascal}Dto = Omit<${singularPascal}Dto, "id">;
-export type Update${singularPascal}Dto = Partial<Omit<${singularPascal}Dto, "id">>;
-
-export type ${singularPascal}Filters = Record<string, string | number | boolean | undefined>;
-
-export const list${pluralPascal} = (
-    client: ApiClient,
-    filters?: ${singularPascal}Filters
-) => client.get<${singularPascal}Dto[]>(RESOURCE_PATH, { searchParams: filters });
-
-export const get${singularPascal} = (client: ApiClient, id: string) =>
-    client.get<${singularPascal}Dto>(RESOURCE_PATH + "/" + id);
-
-export const create${singularPascal} = (client: ApiClient, payload: Create${singularPascal}Dto) =>
-    client.post<${singularPascal}Dto>(RESOURCE_PATH, { body: payload });
-
-export const update${singularPascal} = (
-    client: ApiClient,
-    id: string,
-    payload: Update${singularPascal}Dto
-) => client.patch<${singularPascal}Dto>(RESOURCE_PATH + "/" + id, { body: payload });
-
-export const delete${singularPascal} = (client: ApiClient, id: string) =>
-    client.delete<void>(RESOURCE_PATH + "/" + id);
-
-`;
-}
-function buildRtkQueryHooksTemplate(options) {
-    const { pascalPlural, pascalSingular, resourceKey, apiImportPath } = options;
-    return `import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
-import type { ApiClient } from "bytekit";
-import {
-    list${pascalPlural},
-    get${pascalSingular},
-    create${pascalSingular},
-    update${pascalSingular},
-    delete${pascalSingular},
-    type ${pascalSingular}Dto,
-    type Create${pascalSingular}Dto,
-    type Update${pascalSingular}Dto,
-    type ${pascalSingular}Filters,
-} from "${apiImportPath}";
-
-const resourceKey = "${resourceKey}";
-
-export const ${pascalSingular.toLowerCase()}Api = createApi({
-    reducerPath: "${pascalSingular.toLowerCase()}Api",
-    baseQuery: fetchBaseQuery({
-        baseUrl: process.env.REACT_APP_API_URL || "",
-    }),
-    tagTypes: ["${pascalSingular}"],
-    endpoints: (builder) => ({
-        list${pascalPlural}: builder.query<${pascalSingular}Dto[], ${pascalSingular}Filters | undefined>({
-            query: (filters) => ({
-                url: resourceKey,
-                params: filters,
-            }),
-            providesTags: ["${pascalSingular}"],
-        }),
-        get${pascalSingular}: builder.query<${pascalSingular}Dto, string>({
-            query: (id) => \`\${resourceKey}/\${id}\`,
-            providesTags: (result, error, id) => [{ type: "${pascalSingular}", id }],
-        }),
-        create${pascalSingular}: builder.mutation<${pascalSingular}Dto, Create${pascalSingular}Dto>({
-            query: (payload) => ({
-                url: resourceKey,
-                method: "POST",
-                body: payload,
-            }),
-            invalidatesTags: ["${pascalSingular}"],
-        }),
-        update${pascalSingular}: builder.mutation<
-            ${pascalSingular}Dto,
-            { id: string; payload: Update${pascalSingular}Dto }
-        >({
-            query: ({ id, payload }) => ({
-                url: \`\${resourceKey}/\${id}\`,
-                method: "PATCH",
-                body: payload,
-            }),
-            invalidatesTags: (result, error, { id }) => [
-                { type: "${pascalSingular}", id },
-                "${pascalSingular}",
-            ],
-        }),
-        delete${pascalSingular}: builder.mutation<void, string>({
-            query: (id) => ({
-                url: \`\${resourceKey}/\${id}\`,
-                method: "DELETE",
-            }),
-            invalidatesTags: ["${pascalSingular}"],
-        }),
-    }),
-});
-
-export const {
-    useList${pascalPlural}Query,
-    useGet${pascalSingular}Query,
-    useCreate${pascalSingular}Mutation,
-    useUpdate${pascalSingular}Mutation,
-    useDelete${pascalSingular}Mutation,
-} = ${pascalSingular.toLowerCase()}Api;
-
-`;
 }
-function buildHooksTemplate(options) {
-    const { pascalPlural, pascalSingular, resourceKey, apiImportPath } = options;
-    return `import {
-    useMutation,
-    useQuery,
-    useQueryClient,
-    type UseMutationOptions,
-    type UseQueryOptions,
-} from "@tanstack/react-query";
-import type { ApiClient } from "bytekit";
-import {
-    list${pascalPlural},
-    get${pascalSingular},
-    create${pascalSingular},
-    update${pascalSingular},
-    delete${pascalSingular},
-    type ${pascalSingular}Dto,
-    type Create${pascalSingular}Dto,
-    type Update${pascalSingular}Dto,
-    type ${pascalSingular}Filters,
-} from "${apiImportPath}";
-
-const resourceKey = ["${resourceKey}"] as const;
-
-export const ${pascalSingular.toLowerCase()}Keys = {
-    all: resourceKey,
-    detail: (id: string) => [...resourceKey, id] as const,
-};
-
-export const use${pascalPlural} = (
-    client: ApiClient,
-    filters?: ${pascalSingular}Filters,
-    options?: UseQueryOptions<${pascalSingular}Dto[], Error>
-) =>
-    useQuery({
-        queryKey: filters ? [...resourceKey, filters] : resourceKey,
-        queryFn: () => list${pascalPlural}(client, filters),
-        ...options,
-    });
-
-export const use${pascalSingular} = (
-    client: ApiClient,
-    id?: string,
-    options?: UseQueryOptions<${pascalSingular}Dto, Error>
-) =>
-    useQuery({
-        queryKey: id ? [...resourceKey, id] : [...resourceKey, "detail"],
-        queryFn: () => {
-            if (!id) {
-                throw new Error("${pascalSingular} id is required");
-            }
-
-            return get${pascalSingular}(client, id);
-        },
-        enabled: Boolean(id),
-        ...options,
-    });
-
-type CreateMutationVars = Create${pascalSingular}Dto;
-type UpdateMutationVars = {
-    id: string;
-    payload: Update${pascalSingular}Dto;
-};
-type DeleteMutationVars = {
-    id: string;
-};
-
-export const useCreate${pascalSingular} = (
-    client: ApiClient,
-    options?: UseMutationOptions<${pascalSingular}Dto, unknown, CreateMutationVars>
-) => {
-    const queryClient = useQueryClient();
-
-    return useMutation({
-        mutationFn: (payload) => create${pascalSingular}(client, payload),
-        ...options,
-        onSuccess(data, variables, context) {
-            queryClient.invalidateQueries(resourceKey);
-            options?.onSuccess?.(data, variables, context);
-        },
-    });
-};
-
-export const useUpdate${pascalSingular} = (
-    client: ApiClient,
-    options?: UseMutationOptions<${pascalSingular}Dto, unknown, UpdateMutationVars>
-) => {
-    const queryClient = useQueryClient();
-
-    return useMutation({
-        mutationFn: ({ id, payload }) => update${pascalSingular}(client, id, payload),
-        ...options,
-        onSuccess(data, variables, context) {
-            queryClient.invalidateQueries(resourceKey);
-            if (variables?.id) {
-                queryClient.invalidateQueries(${pascalSingular.toLowerCase()}Keys.detail(variables.id));
-            }
-            options?.onSuccess?.(data, variables, context);
-        },
-    });
-};
-
-export const useDelete${pascalSingular} = (
-    client: ApiClient,
-    options?: UseMutationOptions<void, unknown, DeleteMutationVars>
-) => {
-    const queryClient = useQueryClient();
-
-    return useMutation({
-        mutationFn: ({ id }) => delete${pascalSingular}(client, id),
-        ...options,
-        onSuccess(data, variables, context) {
-            queryClient.invalidateQueries(resourceKey);
-            if (variables?.id) {
-                queryClient.invalidateQueries(${pascalSingular.toLowerCase()}Keys.detail(variables.id));
-            }
-            options?.onSuccess?.(data, variables, context);
-        },
+async function handleTypeGeneration(options) {
+    const url = new URL(options.url);
+    const endpointName = url.pathname.split("/").filter(Boolean).pop() || "api";
+    // Create src/types directory if it doesn't exist
+    const typesDir = path.join(process.cwd(), "src", "types");
+    await fs.mkdir(typesDir, { recursive: true });
+    const outputPath = path.join("src", "types", `${endpointName}.ts`);
+    const interfaceName = endpointName.charAt(0).toUpperCase() + endpointName.slice(1);
+    await generateTypesFromEndpoint({
+        endpoint: options.url,
+        method: options.method,
+        body: options.body,
+        headers: options.headers,
+        output: outputPath,
+        name: interfaceName,
     });
-};
-
-`;
-}
-function toPascalCase(value) {
-    return value
-        .split(/[^a-zA-Z0-9]/)
-        .filter(Boolean)
-        .map((segment) => segment[0].toUpperCase() + segment.slice(1).toLowerCase())
-        .join("");
 }
-function toSingular(value) {
-    const lower = value.toLowerCase();
-    if (lower.endsWith("ies")) {
-        return `${value.slice(0, -3)}y`;
-    }
-    if (lower.endsWith("ses") ||
-        lower.endsWith("xes") ||
-        lower.endsWith("zes") ||
-        lower.endsWith("ches") ||
-        lower.endsWith("shes")) {
-        return value.slice(0, -2);
+async function handleSimpleFetch(options) {
+    console.log(`\n📡 Fetching ${options.method} ${options.url}...`);
+    try {
+        const response = await fetch(options.url, {
+            method: options.method,
+            headers: {
+                "Content-Type": "application/json",
+                ...options.headers,
+            },
+            body: options.body,
+        });
+        const data = await response.json();
+        console.log(JSON.stringify(data, null, 2));
     }
-    if (lower.endsWith("s")) {
-        return value.slice(0, -1);
+    catch (error) {
+        console.error(`\u001b[31mError:\u001b[0m ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
     }
-    return value;
 }
 function printHelp() {
-    console.log(`sutils <command> [args]
-
-Commands
-  create <resource>         Scaffold API + hooks for a resource.
-  types <endpoint>          Generate TypeScript types from API response.
-
-Run \`sutils create --help\` or \`sutils types --help\` for details.
-`);
-}
-function printCreateHelp() {
-    console.log(`sutils create <resource> [options]
-
-Options
-  --apiDir=<dir>            Base directory for API files (default: api).
-  --hooksDir=<dir>          Base directory for hooks (default: hooks).
-  --route=</path>           API route path (default: derived from resource).
-  --queryLib=<lib>          Query library: "react-query" or "rtk-query" (default: react-query).
-  --force                   Overwrite existing files.
-
-Examples
-  sutils create users
-  sutils create users --queryLib=rtk-query
-  sutils create posts --apiDir=src/api --hooksDir=src/hooks --force
-`);
-}
-function printTypesHelp() {
-    console.log(`sutils types <endpoint> [options]
-
-Options
-  --method=<METHOD>         HTTP method (default: GET).
-  --output=<file>           Output file path (default: types.ts).
-  --name=<name>             Type name (default: ApiResponse).
-  --header=<key:value>      Custom header (can be used multiple times).
-
-Examples
-  sutils types https://api.example.com/users
-  sutils types https://api.example.com/users --output=user-types.ts --name=User
-  sutils types https://api.example.com/users --method=POST --header=Authorization:Bearer token
+    console.log(`
+\u001b[1mbytekit CLI\u001b[0m - API Inspection & Type Generation
+
+\u001b[1mUsage:\u001b[0m
+  bytekit [options] <url>
+
+\u001b[1mOptions:\u001b[0m
+  --type                Generate TypeScript types from a single API response.
+                        Saves to src/types/{endpoint}.ts
+  --swagger             Generate all TypeScript DTOs from a Swagger/OpenAPI spec.
+                        Saves to src/types/api-docs.ts
+  --method=<METHOD>     HTTP method (GET, POST, PUT, DELETE, PATCH). Default: GET.
+  --body=<body>         JSON body for the request.
+  --header=<key:val>    Custom HTTP header (can be used multiple times).
+  --headers=<key:val>   Alias for --header.
+
+\u001b[1mExamples:\u001b[0m
+  bytekit https://api.example.com/users
+  bytekit --type https://api.example.com/users
+  bytekit --swagger https://api.example.com/swagger.json
+  bytekit --type --method=POST --body='{"name":"test"}' https://api.example.com/users
 `);
 }
 if (process.argv[1] === fileURLToPath(import.meta.url)) {