├── .eslintignore
├── .eslintrc.json
├── .gitignore
├── .mocharc.json
├── .prettierrc
├── .svetchrc
├── .svetchrc.backup
├── .swcrc
├── .vscode
    ├── launch.json
    └── settings.json
├── README.md
├── backup
    └── docs
    │   ├── +page.svelte
    │   └── components
    │       ├── BodyBlock.svelte
    │       └── Collapsible.svelte
├── bin.ts
├── biome.json
├── build.config.ts
├── build.js
├── bun.lockb
├── example.ts
├── isolate-0x6a571e0-1696734-v8.log
├── package.json
├── prisma
    └── schema.prisma
├── prompt.sh
├── src
    ├── assets
    │   ├── api.ts
    │   ├── client.ts
    │   ├── docs
    │   │   └── +page.svelte
    │   └── interfaces.ts
    ├── bin.ts
    ├── generator.ts
    ├── index.ts
    ├── init.ts
    ├── lib
    │   └── parsers
    │   │   ├── express
    │   │       └── responses.ts
    │   │   └── sveltekit
    │   │       └── responses.ts
    ├── routes
    │   ├── +page.server.ts
    │   ├── +page.svelte
    │   ├── api
    │   │   └── prisma
    │   │   │   └── [id]
    │   │   │       └── +server.ts
    │   └── docs
    │   │   └── +page.svelte
    ├── telemetry.json
    ├── types
    │   ├── core.ts
    │   └── telemetry.ts
    └── utils
    │   ├── check_package.ts
    │   ├── endpoint_extractors.ts
    │   ├── helpers
    │       ├── mock.ts
    │       └── type.ts
    │   ├── import-utils.ts
    │   ├── logger.ts
    │   ├── node_utils.ts
    │   ├── openapi.ts
    │   ├── svelte-codegen.ts
    │   ├── tsoa.ts
    │   ├── unroll-types.ts
    │   ├── util.ts
    │   ├── ux
    │       ├── progress_bar.ts
    │       └── spinner.ts
    │   └── writers.ts
├── static
    └── api
    │   └── schemas
    │       └── swagger.json
├── tests
    └── dependencies.ts
└── tsconfig.json


/.eslintignore:
--------------------------------------------------------------------------------
1 | /dist
2 | 


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": ["oclif", "oclif-typescript", "prettier"]
3 | }
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *-debug.log
 2 | *-error.log
 3 | **/.DS_Store
 4 | /.idea
 5 | /dist
 6 | /tmp
 7 | /node_modules
 8 | oclif.manifest.json
 9 | /src/lib/api
10 | /src/api/schemas
11 | yarn.lock
12 | package-lock.json
13 | 
14 | 
15 | 


--------------------------------------------------------------------------------
/.mocharc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "require": [
 3 |     "ts-node/register"
 4 |   ],
 5 |   "watch-extensions": [
 6 |     "ts"
 7 |   ],
 8 |   "recursive": true,
 9 |   "reporter": "spec",
10 |   "timeout": 60000,
11 |   "node-option": [
12 |     "loader=ts-node/esm",
13 |     "experimental-specifier-resolution=node"
14 |   ]
15 | }
16 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 |     "nonblock-statement-body-position": "error"
3 | }


--------------------------------------------------------------------------------
/.svetchrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "framework": "sveltekit",
 3 |   "input": "src/routes/api",
 4 |   "out": "src/lib/api",
 5 |   "docs": "src/routes/docs",
 6 |   "staticFolder": "static",
 7 |   "tsconfig": "tsconfig.json",
 8 |   "logLevel": 5,
 9 |   "filter": null,
10 |   "telemetry": true
11 | }


--------------------------------------------------------------------------------
/.svetchrc.backup:
--------------------------------------------------------------------------------
 1 | {
 2 |   "framework": "sveltekit",
 3 |   "input": "src/routes/api",
 4 |   "out": "src/lib/api",
 5 |   "docs": "src/routes/docs",
 6 |   "staticFolder": "static",
 7 |   "tsconfig": "tsconfig.json",
 8 |   "logLevel": 5,
 9 |   "filter": null,
10 |   "telemetry": true
11 | }


--------------------------------------------------------------------------------
/.swcrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "$schema": "https://json.schemastore.org/swcrc",
 3 |   "jsc": {
 4 |     "parser": {
 5 |       "syntax": "typescript",
 6 |       "dynamicImport": true,
 7 |       "decorators": false
 8 |     },
 9 |     "target": "esnext",
10 |     "loose": true,
11 |     "externalHelpers": true,
12 |     "keepClassNames": false
13 |   },
14 |   
15 |   "module": {
16 |     "type": "es6",
17 |     "strict": false,
18 |     "strictMode": false,
19 |     "lazy": false,
20 |     "noInterop": false,
21 |     "resolveFully": true
22 |   },
23 |   "minify": false,
24 |   "sourceMaps": true,
25 |   "isModule": true,
26 | 
27 |   "exclude": [
28 |     "node_modules",
29 |     "src/routes/**",
30 |     "src/routes",
31 |     "src/lib/api",
32 |     "src/assets"
33 |   ]
34 | }


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "0.2.0",
 3 |   "configurations": [
 4 |     {
 5 |       "type": "bun",
 6 |       "request": "launch",
 7 |       "name": "Debug Bun",
 8 | 
 9 |       // The path to a JavaScript or TypeScript file to run.
10 |       "program": "${file}",
11 | 
12 |       // The arguments to pass to the program, if any.
13 |       "args": [],
14 | 
15 |       // The working directory of the program.
16 |       "cwd": "${workspaceFolder}",
17 | 
18 |       // The environment variables to pass to the program.
19 |       "env": {},
20 | 
21 |       // If the environment variables should not be inherited from the parent process.
22 |       "strictEnv": false,
23 | 
24 |       // If the program should be run in watch mode.
25 |       // This is equivalent to passing `--watch` to the `bun` executable.
26 |       // You can also set this to "hot" to enable hot reloading using `--hot`.
27 |       "watchMode": false,
28 | 
29 |       // If the debugger should stop on the first line of the program.
30 |       "stopOnEntry": false,
31 | 
32 |       // If the debugger should be disabled. (for example, breakpoints will not be hit)
33 |       "noDebug": false,
34 | 
35 |       // The path to the `bun` executable, defaults to your `PATH` environment variable.
36 |       "runtime": "/root/.bun/bin/bun",
37 | 
38 |       // The arguments to pass to the `bun` executable, if any.
39 |       // Unlike `args`, these are passed to the executable itself, not the program.
40 |       "runtimeArgs": ["run"],
41 |     },
42 |     {
43 |       "type": "bun",
44 |       "request": "attach",
45 |       "name": "Attach to Bun",
46 | 
47 |       // The URL of the WebSocket inspector to attach to.
48 |       // This value can be retrieved by using `bun --inspect`.
49 |       "url": "ws://localhost:6499/",
50 |     }
51 |   ]
52 | }


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     
 3 |     "bun.runtime": "/root/.bun/bin/bun",
 4 |   
 5 |     
 6 |     "bun.debugTerminal.enabled": true,
 7 |     "workbench.sideBar.location": "right",
 8 |     "workbench.panel.defaultLocation": "right",
 9 |     
10 |     
11 |     "bun.debugTerminal.stopOnEntry": false,
12 |     "editor.formatOnSave": true,
13 |     "editor.formatOnSaveMode": "file",
14 |     "[typescript]": { 
15 |       "editor.defaultFormatter": "biomejs.biome"
16 |     },
17 |     "editor.fontFamily": "mononoki"
18 | 
19 |   }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![npm](https://img.shields.io/npm/v/svetch.ts)](https://www.npmjs.com/package/svetch.ts)
  2 | ![svetch-chan (1)](https://github.com/Bewinxed/svetch/assets/9145989/67c36f21-a21e-42f1-ba50-42f457948c46)
  3 | 
  4 | # 🚀 Svetch.ts: Zero-Effort client/types/schema/OpenAPI Schema/Docs generator for your API endpoints
  5 | 
  6 | _Typesafety, Minus the typing_
  7 | 
  8 | 👉 Check it out @ (https://svetch-dev.vercel.app/)
  9 | Effortlessly generate a typesafe Fetch client for your Svelte/Sveltekit applications, complete with automatic input/output zod validation and autogenerated types & API Docs.
 10 | 
 11 | # What is this?
 12 | 
 13 | Svetch automatically scans your `+server.ts` files in /src/routes/api (or whatever directory you specify) and generates a typesafe Fetch client that has intellisense for path, query, body parameters & all the possible responses (and errors)
 14 | 
 15 | # 🧙‍♂️ Automatic Detection
 16 | 
 17 | - ❓ **Query Params** => Detected using any declarations of `url.searchParams.get`
 18 | - 📂 **Path Params** => Detected from the file directory
 19 | - 📦 **Payload Definition** => inferred from `const payload: X = await request.json` or `as X`
 20 | - 💬 **Response Definition** => inferred from any return statement with `json(X) (sveltekit utility)` or `new Response(X)`
 21 | - 📛 **Error Definitions** => inferred from any throw statement with `throw error()` or `throw new Error` or `return error(HTTP_CODE, error_message)`
 22 | 
 23 | # ⏬ How to run
 24 | 
 25 | `$ npx svetch.ts@latest`
 26 | 
 27 | ### Make sure you have a path alias for src in your `svelte.config.js`
 28 | 
 29 | ```diff
 30 | import adapter from '@sveltejs/adapter-auto';
 31 | import { vitePreprocess } from '@sveltejs/kit/vite';
 32 | 
 33 | /** @type {import('@sveltejs/kit').Config} */
 34 | const config = {
 35 | 	// Consult https://kit.svelte.dev/docs/integrations#preprocessors
 36 | 	// for more information about preprocessors
 37 | 	preprocess: vitePreprocess(),
 38 | 	kit: {
 39 | 		// adapter-auto only supports some environments, see https://kit.svelte.dev/docs/adapter-auto for a list.
 40 | 		// If your environment is not supported or you settled on a specific environment, switch out the adapter.
 41 | 		// See https://kit.svelte.dev/docs/adapters for more information about adapters.
 42 | 		adapter: adapter(),
 43 | +		alias: {
 44 | +			"src": "./src",
 45 | 		},
 46 | 	}
 47 | };
 48 | 
 49 | export default config;
 50 | 
 51 | ```
 52 | 
 53 | # 🌟 Advantages
 54 | 
 55 | - 😍 **ALMOST** no code changes required to your existing API code
 56 | - 🚀 Almost no learning curve, Augments a regular FETCH client with **data** and **error** along with the rest of the fetch client properties, you can use it just like a regular fetch client.
 57 | - 🔎 **Intellisense** for your api paths.
 58 | - ✅ Typesafety for api inputs & outputs.
 59 | - 📚 Generates an OpenAPI Schema for your API, alongside with Swagger docs.
 60 | - 📃 Can use **JSDocs** to add more info to the endpoint documentation (WIP)
 61 | - 🤖 Handles multiple possible responses per http code.
 62 | 
 63 | ## Autogenerated Docs
 64 | 
 65 | The library will generate an OpenAPI compatible schema, alongside with swagger docs, by default in /docs/+page.svelte
 66 | 
 67 | # ⚙ Config
 68 | 
 69 | `.svetchrc`
 70 | 
 71 | ```json
 72 | {
 73 |   "framework": "sveltekit", // currently the only option
 74 |   "input": "src/routes/api", // the directory you want the generator to traverse
 75 |   "out": "src/lib/api", // the directory to output the types & the client to
 76 |   "docs": "src/routes/docs", // where to output docs
 77 |   "tsconfig": "tsconfig.json" // your tsconfig directory
 78 | }
 79 | ```
 80 | 
 81 | # 🔎 Detection
 82 | 
 83 | 1. Svetch will traverse your input directory, will scan for any +server.ts with exported GET/POST/PUT/DELETE functions.
 84 | 2. For each endpoint it will detect...
 85 |    1. **path parameters**: based on the file name, e.g. `user/[user_id].ts` will have a path parameter of `user_id`
 86 |    2. **query parameters**: based on any parameters instantiated like `url.searchParams.get('param')`
 87 |    3. **body parameters**: based on the type of the payload `Must be assigned to a const called` **payload** **⚠ IMPORTANT**
 88 |    4. **response types**: will pickup any top-level return statement that is instantiated like **json(xxx)** or **new Response(xxx)** along with status code
 89 | 
 90 | ## In client code
 91 | 
 92 | ```ts
 93 | import { Svetch } from "src/lib/api/client"; // or wherever you chose to generate the client
 94 | 
 95 | const svetch = new Svetch({
 96 |   baseUrl: "/api", // default is '/api'
 97 |   fetch, // default is window.fetch, pass the global fetch to it in node, etc...
 98 |   validate: false, // default is false, uses Zod to validate payload + response (ON CLIENT THIS CAN MAKE THE IMPORT SIZE HUGE)
 99 | });
100 | 
101 | await svetch
102 |   .post("user/[user_id]", {
103 |     path: {
104 |       user_id: 1,
105 |     },
106 |     body: {
107 |       text: foodInput,
108 |       journalId: $journal.id,
109 |       today: new Date(),
110 |     },
111 |   })
112 |   .then((response) => {
113 |     if (response.error) throw new Error(response.error);
114 |     food = response.data;
115 |     loading = false;
116 |   })
117 |   .catch((error) => {
118 |     throw new Error(error);
119 |   });
120 | ```
121 | 
122 | ## In load functions
123 | 
124 | ```ts
125 | import { Svetch } from "src/lib/api/client"; // or wherever you chose to generate the client
126 | 
127 | const svetch = new Svetch({
128 |   baseUrl: "/api", // default is '/api'
129 |   fetch, // pass the load function's fetch to it
130 | });
131 | 
132 | export async function load({ fetch, session }) {
133 |   const user = await svetch.get("user").then((response) => {
134 |     if (response.error) throw new Error(response.error);
135 |     return response.data;
136 |   });
137 |   return {
138 |     props: {
139 |       user,
140 |     },
141 |   };
142 | }
143 | ```
144 | 
145 | # License
146 | 
147 | This library is **Free** for personal use, If it's useful to you, please consider purchasing a license @ https://petrasolutions.lemonsqueezy.com/checkout/buy/19210e05-ae3c-41a0-920c-324e3083618d
148 | Redistribution/Forking is **Not** Allowed.
149 | 


--------------------------------------------------------------------------------
/backup/docs/+page.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import Icon from "@iconify/svelte";
  3 |   import { Svetch } from "[CLIENT_PATH]";
  4 |   import { onMount } from "svelte";
  5 |   import { quintInOut } from "svelte/easing";
  6 |   import { fly, slide } from "svelte/transition";
  7 |   import BodyBlock from "./components/BodyBlock.svelte";
  8 |   import Collapsible from "./components/Collapsible.svelte";
  9 | 
 10 |   let schema: Record<string, any>;
 11 | 
 12 |   let table_of_contents: HTMLDialogElement;
 13 |   // load schema from /api.json
 14 | 
 15 |   // colors for each HTTP method
 16 |   const colors: Record<string, string> = {
 17 |     GET: "bg-green-500",
 18 |     POST: "bg-blue-500",
 19 |     PUT: "bg-yellow-500",
 20 |     DELETE: "bg-red-500",
 21 |     PATCH: "bg-purple-500",
 22 |   };
 23 | 
 24 |   const text_colors: Record<string, string> = {
 25 |     GET: "text-green-500",
 26 |     POST: "text-blue-500",
 27 |     PUT: "text-yellow-500",
 28 |     DELETE: "text-red-500",
 29 |     PATCH: "text-purple-500",
 30 |   };
 31 | 
 32 |   // icons for each HTTP method
 33 |   const icons: Record<string, string> = {
 34 |     GET: "carbon:document-download",
 35 |     POST: "carbon:gateway-mail",
 36 |     PUT: "carbon:row-insert",
 37 |     DELETE: "carbon:row-delete",
 38 |     PATCH: "carbon:edit",
 39 |   };
 40 | 
 41 |   let working = false;
 42 |   let path_being_tested: string = "";
 43 |   let method_being_tested: string = "";
 44 |   let testing_response: unknown;
 45 |   let error_response: unknown;
 46 |   let error_cause: string | undefined;
 47 | 
 48 |   let testing_params: Record<string, Record<string, any>> = {
 49 |     body: {},
 50 |     path: {},
 51 |     query: {},
 52 |   };
 53 | 
 54 |   async function testAPI(method: string, endpoint: string) {
 55 |     const { body, path, query } = testing_params;
 56 |     working = true;
 57 |     testing_response = null;
 58 |     error_response = null;
 59 |     const options: RequestInit = {
 60 |       method: method,
 61 |       headers: {
 62 |         "Content-Type": "application/json",
 63 |       },
 64 |     };
 65 | 
 66 |     if (body) {
 67 |       options.body = JSON.stringify(body);
 68 |     }
 69 | 
 70 |     const svetch = new Svetch({
 71 |       baseUrl: "/api",
 72 |       fetch: fetch,
 73 |       validate: true,
 74 |     });
 75 | 
 76 |     try {
 77 |       const { data, error, statusText } = await svetch.request(
 78 |         endpoint,
 79 |         method,
 80 |         {
 81 |           // type: ignore
 82 |           body: ["GET"].includes(method) ? undefined : body,
 83 |           path: path,
 84 |           query: query,
 85 |         }
 86 |       );
 87 |       if (data) {
 88 |         testing_response = data;
 89 |       } else {
 90 |         error_response = statusText;
 91 |         error_cause = error;
 92 |       }
 93 |       // Process the response data
 94 |       console.log(data);
 95 |       working = false;
 96 |     } catch (e) {
 97 |       working = false;
 98 |       const error = e as {
 99 |         message: string;
100 |         cause: string;
101 |       };
102 |       error_response = error.message;
103 |       error_cause = JSON.parse(error.cause).message
104 |         ? JSON.parse(error.cause).message
105 |         : error.cause;
106 |       console.error("Error:", error, error_cause);
107 |     }
108 |   }
109 | 
110 |   async function loadSchema() {
111 |     const schemas = await Promise.all(["GET", "POST", "PUT", "PATCH", "DELETE"].map(async (method) => {
112 |       return await fetch(`/api/schemas/${method}.json`).then((res) => {
113 |         if (res.ok) {
114 |           return res.json();
115 |         } else {
116 |           throw new Error("Failed to load schema");
117 |         }
118 |       });
119 |     }));
120 |     // combine all objects each entries into one {...GET, ...POST, ...PUT, ...PATCH, ...DELETE}
121 |     schema = schemas.reduce((acc, schema) => {
122 |       return Object.assign(acc, schema);
123 |     }, {});
124 |   }
125 | 
126 |   onMount(async () => {
127 |     // listen to ctrl k
128 |     document.addEventListener("keydown", (e) => {
129 |       if (e.ctrlKey && e.key === "k") {
130 |         e.preventDefault();
131 |         table_of_contents.showModal();
132 |       }
133 |     });
134 |   });
135 | </script>
136 | 
137 | {#await loadSchema()}
138 |   <!-- nicely formatted loader -->
139 |   <div
140 |     transition:fly
141 |     class="flex h-screen w-full place-content-center place-items-center"
142 |   >
143 |     <div transition:fly={{ duration: 500 }} class="card bg-base-100 shadow-lg">
144 |       <div class="card-body flex flex-col items-center">
145 |         <div class="text-center">
146 |           <div class="flex items-center justify-center">
147 |             <Icon icon="carbon:api" class="h-6 w-6 animate-spin" />
148 |           </div>
149 |           <h1 class="mt-4 text-2xl font-bold">Svetch API Docs</h1>
150 |           <!-- link to svetch repo -->
151 |           <a
152 |             href="https://github.com/Bewinxed/svetch
153 | "
154 |             class="text-primary underline">Svetch Docs</a
155 |           >
156 |         </div>
157 |       </div>
158 |     </div>
159 |   </div>
160 | {:then}
161 |   {#if schema}
162 |     <dialog
163 |       in:fly|local={{
164 |         x: 50,
165 |         y: 50,
166 |         duration: 300,
167 |         delay: 300,
168 |         easing: quintInOut,
169 |       }}
170 |       out:fly|local={{
171 |         x: -50,
172 |         y: -50,
173 |         duration: 300,
174 |         delay: 300,
175 |         easing: quintInOut,
176 |       }}
177 |       bind:this={table_of_contents}
178 |       class="modal"
179 |     >
180 |       <form method="dialog" class="modal-box">
181 |         <h3 class="mb-2 text-lg font-bold">Table of Contents</h3>
182 |         <ul class="menu rounded-box bg-base-200 lg:min-w-max">
183 |           {#each Object.entries(schema.properties) as [path, methods]}
184 |             {#if methods && methods.properties}
185 |               <li>
186 |                 <details open>
187 |                   <summary
188 |                     ><a
189 |                       class="inline-flex place-items-center space-x-2"
190 |                       href="#{path}"
191 |                       ><Icon inline icon="carbon:api" /><span>{path}</span></a
192 |                     ></summary
193 |                   >
194 |                   <ul>
195 |                     {#each Object.keys(methods.properties) as method (method)}
196 |                       <li class="{text_colors[method]} font-bold">
197 |                         <a href="#{path}-{method}"
198 |                           ><Icon icon={icons[method]} />{method}</a
199 |                         >
200 |                       </li>
201 |                     {/each}
202 |                   </ul>
203 |                 </details>
204 |               </li>
205 |             {/if}
206 |           {/each}
207 |         </ul>
208 | 
209 |         <div class="modal-action">
210 |           <!-- if there is a button in form, it will close the modal -->
211 |           <button class="btn">Close</button>
212 |         </div>
213 |       </form>
214 |     </dialog>
215 | 
216 |     <div class="drawer">
217 |       <input id="my-drawer-3" type="checkbox" class="drawer-toggle" />
218 |       <div class="drawer-content flex flex-col">
219 |         <!-- sticky Navbar -->
220 |         <div class="navbar sticky top-0 z-10 w-full bg-base-300">
221 |           <div class="flex-none lg:hidden">
222 |             <label for="my-drawer-3" class="btn-ghost btn-square btn">
223 |               <svg
224 |                 xmlns="http://www.w3.org/2000/svg"
225 |                 fill="none"
226 |                 viewBox="0 0 24 24"
227 |                 class="inline-block h-6 w-6 stroke-current"
228 |                 ><path
229 |                   stroke-linecap="round"
230 |                   stroke-linejoin="round"
231 |                   stroke-width="2"
232 |                   d="M4 6h16M4 12h16M4 18h16"
233 |                 /></svg
234 |               >
235 |             </label>
236 |           </div>
237 |           <div class="mx-2 flex-1 px-2">Svetch Docs</div>
238 |           <div class="hidden flex-none lg:block">
239 |             <ul class="menu menu-horizontal">
240 |               <button
241 |                 class="btn-ghost btn"
242 |                 on:click={() => table_of_contents.showModal()}
243 |                 ><Icon icon="carbon:list" />Quick Jump</button
244 |               >
245 |               <!-- Navbar menu content here -->
246 |               <!-- <li><a>Navbar Item 1</a></li> -->
247 |               <!-- <li><a>Navbar Item 2</a></li> -->
248 |             </ul>
249 |           </div>
250 |         </div>
251 |         <!-- Page content here -->
252 |         <div class="container mx-auto flex flex-col space-y-4">
253 |           <h1 class="my-4 text-2xl font-bold" />
254 |           <p class="text-base-content">Autogenerated from '/api/*'</p>
255 | 
256 |           {#if schema.properties}
257 |             {#each Object.entries(schema.properties) as [path, paths]}
258 |               <div class="card card-compact w-full bg-base-100 shadow-xl">
259 |                 <figure class="h-10">
260 |                   <svg
261 |                     id="patternId"
262 |                     width="100%"
263 |                     height="100%"
264 |                     xmlns="http://www.w3.org/2000/svg"
265 |                     ><defs
266 |                       ><pattern
267 |                         id="a"
268 |                         patternUnits="userSpaceOnUse"
269 |                         width="50.222"
270 |                         height="29.003"
271 |                         patternTransform="scale(3) rotate(50)"
272 |                         ><rect
273 |                           x="0"
274 |                           y="0"
275 |                           width="100%"
276 |                           height="100%"
277 |                           fill="hsla(63,27.8%,71.8%,1)"
278 |                         /><path
279 |                           d="M58.592-14.503h-16.74m6.277 3.627H56.5l4.188 7.25h-8.373zM60.686 3.623l-4.187 7.25h-8.372l4.187-7.25zM41.852-7.252l4.185 7.25-4.185 7.252L37.666 0zm25.11 7.25L58.593 14.5h-16.74L33.481-.001l8.371-14.501m16.74-.001l8.37 14.502m0 0h-16.74v0m-8.37-14.501l8.37 14.502-8.37 14.503M8.371-14.502H-8.37m6.276 3.627h8.371l4.188 7.25H2.093zM10.464 3.624l-4.186 7.25h-8.373l4.187-7.25zM-8.37-7.251L-4.185 0-8.37 7.252-12.556 0zM16.74 0l-8.37 14.502H-8.37L-16.742 0l8.371-14.501m16.74-.001L16.741-.001m0 0H.001v0m-8.37-14.501L0 0l-8.37 14.503m6.275 3.625h8.372l4.187 7.25H2.093zm12.558 14.499l-4.187 7.25h-8.372l4.187-7.25zM-8.371 21.752l4.185 7.25-4.185 7.252-4.185-7.251zm25.112 7.25L8.37 43.504H-8.37l-8.371-14.502 8.37-14.501M8.37 14.5l8.372 14.502m0 0H0v0M-8.37 14.502L0 29.003l-8.37 14.503M48.13 18.127l8.371.001 4.188 7.25h-8.373zm12.557 14.5l-4.187 7.249-8.372.001 4.187-7.25zM41.852 21.751l4.185 7.25-4.185 7.252-4.186-7.252zm25.11 7.25l-8.37 14.502h-16.74L33.48 29.003m25.11-14.503l8.372 14.503m0 0h-16.74v0m-8.371-14.501l8.37 14.501-8.37 14.503M33.482 0h-16.74m6.276 3.627l8.371.001 4.188 7.25h-8.373zm12.557 14.5l-4.187 7.249-8.372.001 4.187-7.25zM16.741 7.25l4.185 7.25-4.185 7.252-4.186-7.252zm25.11 7.25l-8.37 14.502h-16.74m25.11-14.502h-16.74v0M16.742 0l8.37 14.502-8.37 14.503"
280 |                           stroke-linecap="square"
281 |                           stroke-width="3"
282 |                           stroke="hsla(353,22.4%,22.7%,1)"
283 |                           fill="none"
284 |                         /></pattern
285 |                       ></defs
286 |                     ><rect
287 |                       width="800%"
288 |                       height="800%"
289 |                       transform="translate(0,0)"
290 |                       fill="url(#a)"
291 |                     /></svg
292 |                   >
293 |                 </figure>
294 |                 <div class="card-body">
295 |                   <div
296 |                     id={path}
297 |                     class="card-title w-full rounded-lg border border-black p-2 text-xl shadow-xl"
298 |                   >
299 |                     <Icon class="inline" inline icon="carbon:folders" />
300 |                     {#each path.split("/") as path_part}
301 |                       {"/"}
302 |                       {#if path_part.includes(":")}
303 |                         <div
304 |                           class="badge badge-lg rounded-md bg-gray-500 text-white"
305 |                         >
306 |                           {path_part.replace(":", "")}
307 |                         </div>
308 |                       {:else}
309 |                         <span class="text-base font-semibold">{path_part}</span>
310 |                       {/if}
311 |                     {/each}
312 |                   </div>
313 |                   {#if paths && paths.properties}
314 |                     {#each Object.entries(paths.properties) as [method, method_data]}
315 |                       <div class="md:ml-2">
316 |                         <Collapsible>
317 |                           <svelte:fragment slot="title">
318 |                             <div
319 |                               class="inline-flex place-items-center space-x-2"
320 |                             >
321 |                               <div
322 |                                 id="{path}-{method}"
323 |                                 class="badge {colors[
324 |                                   method
325 |                                 ]} badge-lg gap-2 text-white"
326 |                               >
327 |                                 <Icon icon={icons[method]} />
328 |                                 {method}
329 |                               </div>
330 |                               {#if method_data.description}
331 |                                 <div class="text-sm font-normal italic">
332 |                                   {method_data.description}
333 |                                 </div>
334 |                               {/if}
335 |                             </div>
336 |                           </svelte:fragment>
337 |                           <div class="flex flex-col space-y-2">
338 |                             {#if typeof method_data === "object" && method_data.properties && method_data.properties.parameters}
339 |                               {@const parameters =
340 |                                 method_data.properties.parameters.properties}
341 |                               {@const responses =
342 |                                 method_data.properties.responses}
343 |                               {@const errors = method_data.properties.errors}
344 |                               {@const testing =
345 |                                 path_being_tested == path &&
346 |                                 method_being_tested == method}
347 |                               {#if parameters}
348 |                                 <div class="card-title text-xl font-medium">
349 |                                   <Icon
350 |                                     class="inline"
351 |                                     inline
352 |                                     icon="carbon:parameter"
353 |                                   />
354 |                                   <span>Parameters</span>
355 |                                 </div>
356 |                                 {#if path_being_tested == path && method_being_tested == method && parameters.path && parameters.path.properties}
357 |                                   <!-- replace the \n with newlines -->
358 |                                   <div class="contents" transition:slide>
359 |                                     <h4 class="text-sm font-normal">
360 |                                       <Icon
361 |                                         class="inline"
362 |                                         inline
363 |                                         icon="carbon:folders"
364 |                                       /> Path
365 |                                     </h4>
366 |                                     <div class="m-2 flex space-x-2">
367 |                                       {#each Object.entries(parameters.path.properties) as [param, type]}
368 |                                         <div class="badge badge-primary gap-2">
369 |                                           {param}
370 |                                         </div>
371 |                                         <input
372 |                                           class="input-primary input"
373 |                                           type="text"
374 |                                           name={param}
375 |                                           id={param}
376 |                                           bind:value={testing_params.path[
377 |                                             param
378 |                                           ]}
379 |                                         />
380 |                                       {/each}
381 |                                     </div>
382 |                                   </div>
383 |                                 {/if}
384 |                                 <div
385 |                                   class="rounded-lg border border-gray-300 p-2 shadow-inner"
386 |                                 >
387 |                                   {#if parameters.body && parameters.body.properties}
388 |                                     <h4 class="text-lg font-semibold">
389 |                                       <Icon
390 |                                         class="inline"
391 |                                         inline
392 |                                         icon="carbon:document-multiple-02"
393 |                                       /> Body
394 |                                     </h4>
395 |                                     <div
396 |                                       class="mockup-code m-2 transition-all {path_being_tested ==
397 |                                         path && method_being_tested
398 |                                         ? 'max-h-60 overflow-auto'
399 |                                         : 'max-h-[50rem]'}"
400 |                                     >
401 |                                       <BodyBlock data={parameters.body} />
402 |                                     </div>
403 |                                   {/if}
404 |                                 </div>
405 |                                 <!-- if query is not never -->
406 |                                 {#if parameters.query && parameters.query.properties && Object.entries(parameters.query.properties).length > 0}
407 |                                   <h4 class="text-base font-semibold">Query</h4>
408 |                                   {JSON.stringify(parameters.query)}
409 |                                   <BodyBlock data={parameters.query} />
410 |                                   <!-- <pre>{JSON.stringify(parameters.query, null, 2)}</pre> -->
411 |                                 {/if}
412 |                               {/if}
413 |                               {#if testing && parameters.body && parameters.body.properties}
414 |                                 <div class="form-control">
415 |                                   <label class="label" for="body">
416 |                                     <h2 class="label-text">Body</h2>
417 |                                   </label>
418 |                                   <textarea
419 |                                     rows={Object.keys(testing_params.body)
420 |                                       .length + 2}
421 |                                     class="textarea-bordered textarea-primary textarea h-auto"
422 |                                     name="body"
423 |                                     id="body"
424 |                                     value={JSON.stringify(
425 |                                       testing_params.body,
426 |                                       null,
427 |                                       "\t"
428 |                                     )}
429 |                                     on:input={(e) => {
430 |                                       try {
431 |                                         testing_params.body = JSON.parse(
432 |                                           e.target.value
433 |                                         );
434 |                                       } catch (e) {
435 |                                         console.error(e);
436 |                                       }
437 |                                     }}
438 |                                   />
439 |                                 </div>
440 |                               {/if}
441 | 
442 |                               {#if responses && responses.properties}
443 |                                 <Collapsible
444 |                                   open={!testing}
445 |                                   title="Responses"
446 |                                   icon="carbon:package"
447 |                                 >
448 |                                   {#each Object.entries(responses.properties) as [code, response]}
449 |                                     <div class="ml-2">
450 |                                       <h4 class="text-sm font-normal">
451 |                                         <Icon
452 |                                           class="inline"
453 |                                           inline
454 |                                           icon="carbon:document-multiple"
455 |                                         />
456 |                                         <div
457 |                                           class="badge {parseInt(code) <= 100
458 |                                             ? 'badge-info'
459 |                                             : parseInt(code) <= 200
460 |                                             ? 'badge-success'
461 |                                             : parseInt(code) <= 300
462 |                                             ? 'badge-warning'
463 |                                             : parseInt(code) <= 400
464 |                                             ? 'badge-error'
465 |                                             : 'badge-error'}"
466 |                                         >
467 |                                           {parseInt(code)}
468 |                                         </div>
469 |                                       </h4>
470 |                                       <div
471 |                                         class="mockup-code m-2 transition-all {testing
472 |                                           ? 'max-h-60 overflow-auto'
473 |                                           : 'max-h-[50rem]'}"
474 |                                       >
475 |                                         <BodyBlock data={response} />
476 |                                       </div>
477 |                                     </div>
478 |                                   {/each}
479 |                                 </Collapsible>
480 |                               {/if}
481 |                               {#if errors && errors.properties}
482 |                                 <Collapsible
483 |                                   open={!testing}
484 |                                   title="Errors"
485 |                                   icon="carbon:error-outline"
486 |                                 >
487 |                                   {#each Object.entries(errors.properties) as [code, response]}
488 |                                     <div class="ml-2">
489 |                                       <h4 class="text-sm font-normal">
490 |                                         <Icon
491 |                                           class="inline"
492 |                                           inline
493 |                                           icon="carbon:document-multiple"
494 |                                         />
495 |                                         <div
496 |                                           class="badge {parseInt(code) <= 100
497 |                                             ? 'badge-info'
498 |                                             : parseInt(code) <= 200
499 |                                             ? 'badge-success'
500 |                                             : parseInt(code) <= 300
501 |                                             ? 'badge-warning'
502 |                                             : parseInt(code) <= 400
503 |                                             ? 'badge-error'
504 |                                             : 'badge-error'}"
505 |                                         >
506 |                                           {parseInt(code)}
507 |                                         </div>
508 |                                       </h4>
509 |                                       <div
510 |                                         class="mockup-code m-2 transition-all {path_being_tested ==
511 |                                           path && method_being_tested
512 |                                           ? 'max-h-60 overflow-auto'
513 |                                           : 'max-h-[50rem]'}"
514 |                                       >
515 |                                         <BodyBlock data={response} />
516 |                                       </div>
517 |                                     </div>
518 |                                   {/each}
519 |                                 </Collapsible>
520 |                               {/if}
521 | 
522 |                               {#if path_being_tested === path && method_being_tested === method}
523 |                                 <div class="" transition:slide>
524 |                                   {#if error_response}
525 |                                     <span
526 |                                       class="mb-1 inline-flex flex-row place-items-center space-x-2"
527 |                                       in:fly={{
528 |                                         x: 50,
529 |                                         duration: 200,
530 |                                         delay: 200,
531 |                                       }}
532 |                                       out:fly={{ x: -25, duration: 200 }}
533 |                                     >
534 |                                       <Icon
535 |                                         icon="carbon:error"
536 |                                         class="text-error"
537 |                                       />
538 |                                       <div
539 |                                         class="mockup-code"
540 |                                         transition:slide={{ duration: 200 }}
541 |                                       >
542 |                                         <pre class="text-error"><code
543 |                                             >{JSON.stringify(
544 |                                               error_response,
545 |                                               null,
546 |                                               2
547 |                                             )}</code
548 |                                           ></pre>
549 |                                       </div>
550 |                                     </span>
551 |                                     {#if error_cause}
552 |                                       <div
553 |                                         class="mockup-code"
554 |                                         transition:slide={{ duration: 200 }}
555 |                                       >
556 |                                         <pre class="text-error"><code
557 |                                             >{JSON.stringify(
558 |                                               error_cause,
559 |                                               null,
560 |                                               2
561 |                                             )}</code
562 |                                           ></pre>
563 |                                       </div>
564 |                                     {/if}
565 |                                   {:else if testing_response}
566 |                                     <span
567 |                                       class="inline-flex flex-row place-items-center space-x-2"
568 |                                       in:fly={{
569 |                                         x: 50,
570 |                                         duration: 200,
571 |                                         delay: 200,
572 |                                       }}
573 |                                       out:fly={{ x: -25, duration: 200 }}
574 |                                     >
575 |                                       <Icon
576 |                                         icon="carbon:checkmark"
577 |                                         class="text-success"
578 |                                       />
579 |                                       Success!
580 |                                     </span>
581 |                                     <div
582 |                                       class="mockup-code w-full"
583 |                                       transition:slide={{ duration: 200 }}
584 |                                     >
585 |                                       <pre
586 |                                         class="whitespace-pre-wrap break-words"><code
587 |                                           >{JSON.stringify(
588 |                                             testing_response,
589 |                                             null,
590 |                                             "\t"
591 |                                           )}</code
592 |                                         ></pre>
593 |                                     </div>
594 |                                   {:else if working}
595 |                                     <span
596 |                                       class="inline-flex flex-row place-items-center space-x-2"
597 |                                       in:fly={{
598 |                                         x: 50,
599 |                                         duration: 200,
600 |                                         delay: 200,
601 |                                       }}
602 |                                       out:fly={{ x: -25, duration: 200 }}
603 |                                     >
604 |                                       <Icon
605 |                                         icon="carbon:circle-dash"
606 |                                         class="animate-spin"
607 |                                       />
608 |                                       <span>Testing...</span>
609 |                                     </span>
610 |                                   {/if}
611 |                                 </div>
612 |                               {/if}
613 | 
614 |                               <div class="card-actions justify-end">
615 |                                 <button
616 |                                   class="btn-secondary btn"
617 |                                   on:click={() => {
618 |                                     // set focus to the first input
619 | 
620 |                                     if (
621 |                                       path_being_tested !== path ||
622 |                                       method_being_tested !== method
623 |                                     ) {
624 |                                       testing_response = null;
625 |                                       error_response = null;
626 |                                       error_cause = "";
627 |                                     }
628 |                                     path_being_tested = path;
629 |                                     method_being_tested = method;
630 |                                     if (
631 |                                       parameters?.body &&
632 |                                       parameters?.body.properties
633 |                                     ) {
634 |                                       testing_params.body = Object.entries(
635 |                                         parameters.body.properties
636 |                                       ).reduce((acc, [key, value]) => {
637 |                                         if (value.type == "number") {
638 |                                           acc[key] = 0;
639 |                                         } else if (value.type == "boolean") {
640 |                                           acc[key] = false;
641 |                                         } else if (value.type == "string") {
642 |                                           if (
643 |                                             value.format &&
644 |                                             value.format == "date-time"
645 |                                           ) {
646 |                                             acc[key] = new Date().toISOString();
647 |                                           } else if (
648 |                                             value.format &&
649 |                                             value.format == "date"
650 |                                           ) {
651 |                                             acc[key] = new Date().toISOString();
652 |                                           } else {
653 |                                             acc[key] = "";
654 |                                           }
655 |                                         } else if (value.type == "array") {
656 |                                           acc[key] = [];
657 |                                         } else if (value.type == "object") {
658 |                                           acc[key] = {};
659 |                                         } else if (value.type == "date") {
660 |                                           acc[key] = new Date().toISOString();
661 |                                         } else if (value.type == "date-time") {
662 |                                           acc[key] = new Date().toISOString();
663 |                                         } else {
664 |                                           acc[key] = null;
665 |                                         }
666 |                                         return acc;
667 |                                       }, {});
668 |                                     }
669 |                                     const firstInput = document.getElementById(
670 |                                       `${path}-${method}`
671 |                                     );
672 |                                     if (firstInput) {
673 |                                       // delay to allow the collapsible to open
674 |                                       window.scrollTo({
675 |                                         top: firstInput.offsetTop - 100,
676 |                                         behavior: "smooth",
677 |                                       });
678 |                                     }
679 |                                   }}>Try</button
680 |                                 >
681 |                                 <button
682 |                                   class="btn-primary btn"
683 |                                   on:click={() => testAPI(method, path)}
684 |                                   >Test</button
685 |                                 >
686 |                               </div>
687 |                             {/if}
688 |                           </div>
689 |                         </Collapsible>
690 |                       </div>
691 |                     {/each}
692 |                   {/if}
693 |                 </div>
694 |               </div>
695 |             {/each}
696 |           {/if}
697 |         </div>
698 |       </div>
699 |       <div class="drawer-side">
700 |         <label for="my-drawer-3" class="drawer-overlay" />
701 | 
702 |         <ul class="menu mt-16 h-full w-fit bg-base-200">
703 |           {#each Object.entries(schema.properties) as [path, methods]}
704 |             {#if methods && methods.properties}
705 |               <li>
706 |                 <details open>
707 |                   <summary
708 |                     ><a
709 |                       class="inline-flex place-items-center space-x-2"
710 |                       href="#{path}"
711 |                       ><Icon inline icon="carbon:api" /><span>{path}</span></a
712 |                     ></summary
713 |                   >
714 |                   <ul>
715 |                     {#each Object.keys(methods.properties) as method (method)}
716 |                       <li class="{text_colors[method]} font-bold">
717 |                         <a href="#{path}-{method}"
718 |                           ><Icon icon={icons[method]} />{method}</a
719 |                         >
720 |                       </li>
721 |                     {/each}
722 |                   </ul>
723 |                 </details>
724 |               </li>
725 |             {/if}
726 |           {/each}
727 |         </ul>
728 |       </div>
729 |     </div>
730 |     <footer class="p-10 footer bg-base-200 text-base-content footer-center">
731 |       <div>
732 |         <span class="footer-title">Autogenerated Docs via Svetch</span>
733 |         <a
734 |           href="https://github.com/Bewinxed/svetch
735 | "
736 |           class="text-primary underline">Svetch Docs</a
737 |         >
738 |       </div>
739 |     </footer>
740 |   {/if}
741 | {:catch error}
742 |   <div class="flex h-screen w-full place-content-center place-items-center">
743 |     <div transition:fly={{ duration: 500 }} class="card bg-base-100 shadow-lg">
744 |       <div class="card-body flex flex-col items-center">
745 |         <div class="text-center">
746 |           <div class="flex items-center justify-center">
747 |             <Icon icon="carbon:error" class="text-5xl text-error" />
748 |           </div>
749 |           <h1 class="mt-4 text-2xl font-bold">Error</h1>
750 |           <p class="mt-2 text-base-content text-opacity-60">{error.message}</p>
751 |         </div>
752 |       </div>
753 |     </div>
754 |   </div>
755 | {/await}
756 | 
757 | <style>
758 |   :global(html) {
759 |     scroll-behavior: smooth;
760 |   }
761 | </style>
762 | 


--------------------------------------------------------------------------------
/backup/docs/components/BodyBlock.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |   import type { RecursiveJSONSchema } from "[INTERFACE_PATH]";
 3 | 
 4 |   const typeColors: Record<string, string> = {
 5 |     string: "text-yellow-500",
 6 |     number: "text-blue-500",
 7 |     boolean: "text-green-500",
 8 |     object: "text-purple-500",
 9 |     array: "text-pink-500",
10 |   };
11 |   export let data: RecursiveJSONSchema;
12 |   export let name: string | undefined = undefined;
13 |   export let required: boolean = false;
14 |   export let level: number = 0;
15 |   const indentSize: number = 2; // Adjust this to control the indent size
16 | </script>
17 | 
18 | {#if data}
19 |   {#if data.type === "object" && data.properties}
20 |     {#each Object.entries(data.properties) as [param, schema] (param)}
21 |       <svelte:self
22 |         data={schema}
23 |         name={param}
24 |         {level}
25 |         required={data.required && data.required.includes(param)}
26 |       />
27 |     {/each}
28 |   {:else if data.type === "array" && data.items}
29 |     <pre class="mb-0 flex h-8 flex-row" data-prefix={level + 1}>
30 | 		<code
31 |         >{name}: <span class:required class={typeColors[data.type]}
32 |           >{data.type}</span
33 |         > [</code
34 |       >
35 | 		<br />
36 | 	
37 | 	</pre>
38 | 
39 |     <div
40 |       class="my-1 ml-12 border-b border-l border-dashed border-gray-300 py-2 pl-0"
41 |     >
42 |       <svelte:self data={data.items} level={level + 1} required={data} />
43 |       <span class="ml-6">]</span>
44 |     </div>
45 |   {:else}
46 |     <pre class="mb-0 flex h-8 flex-row" data-prefix={level + 1}>
47 | 			
48 | 				
49 | 	<code class:required
50 |         >{name}: <span class={typeColors[data.type]}
51 |           >{data.const ? data.const : data.type}</span
52 |         ></code
53 |       >
54 | </pre>
55 |   {/if}
56 | {/if}
57 | 
58 | <style>
59 |   .required::after {
60 |     content: "*";
61 |     @apply text-secondary;
62 |     margin-left: 0.5rem;
63 |   }
64 | </style>
65 | 


--------------------------------------------------------------------------------
/backup/docs/components/Collapsible.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 | 	import Icon from '@iconify/svelte'
 3 | 
 4 | 	export let open = false
 5 | 	export let title: string | null = null
 6 | 	export let icon: string | null = null
 7 | </script>
 8 | 
 9 | <div class="{$$slots.default ? 'collapse-arrow' : ''} collapse  border-gray-300 border shadow-lg bg-gradient-to-br from-base-200 to-white">
10 | 	<input type="checkbox" name="my-accordion-2" bind:checked={open} />
11 | 	{#if title}
12 | 		<div class="collapse-title text-lg font-medium">
13 | 			{#if icon}
14 | 				<Icon class="inline" inline icon="{icon}" />
15 | 			{/if}
16 | 			<span>{title}</span>
17 | 		</div>
18 | 	{:else}
19 | 		<div class="collapse-title">
20 | 			<slot name="title"><!-- optional fallback --></slot>
21 | 		</div>
22 | 	{/if}
23 | 	<div class="collapse-content shadow-inner">
24 | 		<div class="py-2">
25 | 		<slot />
26 | 	</div>
27 | 	</div>
28 | </div>
29 | 


--------------------------------------------------------------------------------
/bin.ts:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | import { runAll } from './src/index.js';
3 | console.log(import.meta.dirname);
4 | runAll();
5 | 


--------------------------------------------------------------------------------
/biome.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
 3 |   "organizeImports": {
 4 |     "enabled": true
 5 |   },
 6 |   "formatter": {
 7 |     "indentStyle": "tab",
 8 |     "lineWidth": 80,
 9 |     "enabled": true
10 |   },
11 |   "linter": {
12 |     "enabled": true,
13 |     "rules": {
14 |       "recommended": true
15 |     }
16 |   },
17 |   "javascript": {
18 |     "parser": {
19 |       "unsafeParameterDecoratorsEnabled": true
20 |     }
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/build.config.ts:
--------------------------------------------------------------------------------
 1 | import { defineBuildConfig } from 'unbuild'
 2 | import fs from 'fs'
 3 | import path from 'path'
 4 | 
 5 | 
 6 | const copyFolderRecursive = (src: string, dest: string) => {
 7 |   if (!fs.existsSync(dest)) {
 8 |     fs.mkdirSync(dest, { recursive: true });
 9 |   }
10 | 
11 |   const entries = fs.readdirSync(src, { withFileTypes: true });
12 | 
13 |   for (const entry of entries) {
14 |     const srcPath = path.join(src, entry.name);
15 |     const destPath = path.join(dest, entry.name);
16 | 
17 |     if (entry.isDirectory()) {
18 |       copyFolderRecursive(srcPath, destPath);
19 |     } else {
20 |       fs.copyFileSync(srcPath, destPath);
21 |     }
22 |   }
23 | };
24 | 
25 | export default defineBuildConfig({
26 |   entries: [
27 |     "src/bin.ts"
28 |   ],
29 |   clean: true,
30 |   declaration: true, // Generate .d.ts files
31 |   outDir: 'dist',
32 |   rollup: {
33 |     emitCJS: true,
34 |     inlineDependencies: false,
35 | 
36 |   },
37 |   hooks: {
38 |     'build:done': () => {
39 |       const srcDir = path.join(__dirname, 'src/assets');
40 |       const destDir = path.join(__dirname, 'dist/assets');
41 |       
42 |       if (fs.existsSync(srcDir)) {
43 |         copyFolderRecursive(srcDir, destDir);
44 |         console.log('Copied src/assets to dist/assets');
45 |       } else {
46 |         console.warn('Source directory not found: src/assets');
47 |       }
48 |     },
49 |   },
50 | })


--------------------------------------------------------------------------------
/build.js:
--------------------------------------------------------------------------------
 1 | const { execSync } = require('child_process');
 2 | const fs = require('fs-extra');
 3 | const path = require('path');
 4 | 
 5 | // Run SWC
 6 | console.log('Running SWC...');
 7 | execSync('swc src -d dist', { stdio: 'inherit' });
 8 | 
 9 | // Copy assets
10 | console.log('Copying assets...');
11 | const srcDir = path.join(__dirname, 'src/assets');
12 | const destDir = path.join(__dirname, 'dist/assets');
13 | 
14 | if (fs.existsSync(srcDir)) {
15 |   fs.copySync(srcDir, destDir, { overwrite: true });
16 |   console.log('Assets copied successfully.');
17 | } else {
18 |   console.warn('Source assets directory not found.');
19 | }
20 | 
21 | console.log('Build completed.');


--------------------------------------------------------------------------------
/bun.lockb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Bewinxed/svetch/8031f56ac2e947f9e09dc2671312c7d794e7baa9/bun.lockb


--------------------------------------------------------------------------------
/example.ts:
--------------------------------------------------------------------------------
1 | {"query":"string","number":"number"}


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": "Omar Al Matar",
 3 |   "version": "2.1.43",
 4 |   "funding": [
 5 |     "https://petrasolutions.lemonsqueezy.com/checkout/buy/19210e05-ae3c-41a0-920c-324e3083618d"
 6 |   ],
 7 |   "bin": {
 8 |     "svetch.ts": "./dist/src/bin.js"
 9 |   },
10 |   "bugs": {
11 |     "url": "https://github.com/Bewinxed/svetch/issues"
12 |   },
13 |   "dependencies": {
14 |     "ansi-colors": "^4.1.3",
15 |     "comment-parser": "^1.4.1",
16 |     "ora": "^8.1.0",
17 |     "prompts": "^2.4.2",
18 |     "ts-morph": "^23.0.0",
19 |     "tsoa": "^6.4.0"
20 |   },
21 |   "description": "End-to-End typesafe fetch client for your API",
22 |   "devDependencies": {
23 |     "@biomejs/biome": "^1.8.3",
24 |     "@prisma/client": "5.17.0",
25 |     "@swc/cli": "^0.4.0",
26 |     "@swc/core": "^1.7.23",
27 |     "@total-typescript/tsconfig": "^1.0.4",
28 |     "@types/detective": "^5.1.5",
29 |     "@types/inquirer": "^9.0.7",
30 |     "@types/node": "^20.16.3",
31 |     "@types/prompts": "^2.4.9",
32 |     "@types/readline-sync": "^1.4.8",
33 |     "@types/uuid": "^9.0.8",
34 |     "detective-es6": "^4.0.1",
35 |     "lucia": "^3.2.0",
36 |     "openapi-types": "^12.1.3",
37 |     "prisma": "^5.19.1",
38 |     "svetch.ts": "^2.1.41",
39 |     "unbuild": "^2.0.0"
40 |   },
41 |   "exports": {
42 |     ".": {
43 |       "import": "./dist/index.mjs",
44 |       "require": "./dist/index.cjs"
45 |     }
46 |   },
47 |   "files": [
48 |     "dist"
49 |   ],
50 |   "homepage": "https://github.com/Bewinxed/svetch#readme",
51 |   "keywords": [
52 |     "svelte",
53 |     "sveltekit",
54 |     "typescript",
55 |     "fetch",
56 |     "typesafe",
57 |     "svetch.ts",
58 |     "openapi",
59 |     "swagger"
60 |   ],
61 |   "license": "MIT",
62 |   "main": "./dist/src/index.js",
63 |   "module": "./dist/src/index.js",
64 |   "name": "svetch.ts",
65 |   "repository": {
66 |     "type": "git",
67 |     "url": "git+https://github.com/Bewinxed/svetch"
68 |   },
69 |   "scripts": {
70 |     "build": "rm -rf dist && npx swc src -d dist && cp -r src/assets dist/src/assets",
71 |     "bump": "npm version patch",
72 |     "yolo": "npm run bump && bun run build && npm publish"
73 |   },
74 |   "type": "module",
75 |   "types": "./dist/src/index.d.ts"
76 | }
77 | 


--------------------------------------------------------------------------------
/prisma/schema.prisma:
--------------------------------------------------------------------------------
 1 | // This is your Prisma schema file,
 2 | // learn more about it in the docs: https://pris.ly/d/prisma-schema
 3 | 
 4 | // Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
 5 | // Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
 6 | 
 7 | generator client {
 8 |   provider = "prisma-client-js"
 9 | }
10 | 
11 | datasource db {
12 |   provider = "postgresql"
13 |   url      = env("DATABASE_URL")
14 | }
15 | 
16 | model User {
17 |   id        String   @id @default(cuid())
18 |   email     String   @unique
19 |   name      String?
20 |   password  String
21 |   createdAt DateTime @default(now())
22 |   updatedAt DateTime @updatedAt
23 |   posts     Post[]
24 | }
25 | 
26 | model Post {
27 |   id        String   @id @default(cuid())
28 |   title     String
29 |   content   String
30 |   createdAt DateTime @default(now())
31 |   updatedAt DateTime @updatedAt
32 |   author    User     @relation(fields: [authorId], references: [id])
33 |   authorId  String
34 | }
35 | 


--------------------------------------------------------------------------------
/prompt.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Output file
 4 | output_file="combined_code.txt"
 5 | 
 6 | # Empty the output file if it already exists
 7 | > "$output_file"
 8 | 
 9 | # Function to add a file's content to the output
10 | add_file_content() {
11 |     local file=$1
12 |     echo "==== File: $file ====" >> "$output_file"
13 |     cat "$file" >> "$output_file"
14 |     echo -e "\n\n" >> "$output_file"
15 | }
16 | 
17 | # Add src/generator.ts
18 | if [ -f "src/generator.ts" ]; then
19 |     add_file_content "src/generator.ts"
20 | else
21 |     echo "src/generator.ts not found" >> "$output_file"
22 | fi
23 | 
24 | # Add files from src/utils directory
25 | if [ -d "src/utils" ]; then
26 |     for file in src/utils/*; do
27 |         if [ -f "$file" ]; then
28 |             add_file_content "$file"
29 |         fi
30 |     done
31 | else
32 |     echo "src/utils directory not found" >> "$output_file"
33 | fi
34 | 
35 | # Add files from src/types directory
36 | if [ -d "src/types" ]; then
37 |     for file in src/types/*; do
38 |         if [ -f "$file" ]; then
39 |             add_file_content "$file"
40 |         fi
41 |     done
42 | else
43 |     echo "src/types directory not found" >> "$output_file"
44 | fi
45 | 
46 | # add bin and index
47 | add_file_content "bin.ts"
48 | add_file_content "index.ts"
49 | 
50 | echo "All files have been combined into $output_file"


--------------------------------------------------------------------------------
/src/assets/api.ts:
--------------------------------------------------------------------------------
1 | export type GET = object;
2 | export type POST = object;
3 | export type PUT = object;
4 | export type PATCH = object;
5 | export type DELETE = object;
6 | 


--------------------------------------------------------------------------------
/src/assets/client.ts:
--------------------------------------------------------------------------------
  1 | import type { GET, POST, PUT, PATCH, DELETE } from "./api.js";
  2 | 
  3 | const APIPaths = {
  4 | 	GET: {} as GET,
  5 | 	POST: {} as POST,
  6 | 	PUT: {} as PUT,
  7 | 	PATCH: {} as PATCH,
  8 | 	DELETE: {} as DELETE,
  9 | } as const;
 10 | 
 11 | type APIPaths = typeof APIPaths;
 12 | 
 13 | type EndpointMethod<
 14 | 	EP extends keyof APIPaths,
 15 | 	M extends keyof APIPaths[EP],
 16 | > = APIPaths[EP][M];
 17 | 
 18 | // biome-ignore lint/suspicious/noExplicitAny: <explanation>
 19 | type Params<M extends EndpointMethod<any, any>> = M extends {
 20 | 	parameters: infer P;
 21 | }
 22 | 	? { [K in keyof P]: undefined extends P[K] ? P[K] | undefined : P[K] }
 23 | 	: never;
 24 | 
 25 | // biome-ignore lint/suspicious/noExplicitAny: <explanation>
 26 | type SuccessResponse<M extends EndpointMethod<any, any>> = M extends {
 27 | 	responses: { 200: infer S };
 28 | }
 29 | 	? S
 30 | 	: never;
 31 | 
 32 | // biome-ignore lint/suspicious/noExplicitAny: <explanation>
 33 | type ErrorResponse<M extends EndpointMethod<any, any>> = M extends {
 34 | 	errors: infer E;
 35 | }
 36 | 	? E
 37 | 	: never;
 38 | 
 39 | type ExtendedResponse<
 40 | 	EP extends keyof APIPaths,
 41 | 	K extends keyof APIPaths[EP],
 42 | > = Response & {
 43 | 	data?: SuccessResponse<APIPaths[EP][K]>;
 44 | 	error?: ErrorResponse<APIPaths[EP][K]>;
 45 | 	isOk: () => this is ExtendedResponse<EP, K> & {
 46 | 		data: SuccessResponse<APIPaths[EP][K]>;
 47 | 		error: undefined;
 48 | 	};
 49 | 	okOrThrow: () => SuccessResponse<APIPaths[EP][K]>;
 50 | };
 51 | 
 52 | export class Svetch {
 53 | 	private baseURL: string;
 54 | 	private fetchFn: typeof fetch;
 55 | 
 56 | 	constructor(baseURL = "", fetchInstance?: typeof fetch) {
 57 | 		this.baseURL = baseURL;
 58 | 		this.fetchFn = fetchInstance || fetch;
 59 | 	}
 60 | 
 61 | 	error(status: number, message: string) {
 62 | 		const err = new Error(message);
 63 | 		// @ts-ignore
 64 | 		err.status = status;
 65 | 		throw err;
 66 | 	}
 67 | 
 68 | 	async request<M extends keyof APIPaths, EP extends keyof APIPaths[M]>(
 69 | 		endpoint: EP,
 70 | 		method: M,
 71 | 		options: Params<EndpointMethod<M, EP>>,
 72 | 	): Promise<ExtendedResponse<M, EP>> {
 73 | 		const { path, query, body } = options as unknown as {
 74 | 			path?: { [key: string]: string };
 75 | 			query?: { [key: string]: unknown };
 76 | 			body?: {
 77 | 				[key: string]: unknown;
 78 | 			};
 79 | 		};
 80 | 		let updatedEndpoint = endpoint as string;
 81 | 
 82 | 		if (path) {
 83 | 			for (const [key, value] of Object.entries(path)) {
 84 | 				if (value === undefined) {
 85 | 					console.warn(`Path parameter ${key} is undefined, skipping`);
 86 | 					continue;
 87 | 				}
 88 | 				updatedEndpoint = updatedEndpoint.replace(`:${key}`, value as string);
 89 | 			}
 90 | 		}
 91 | 
 92 | 		const query_params = new URLSearchParams();
 93 | 		if (query) {
 94 | 			for (const [key, value] of Object.entries(query)) {
 95 | 				if (value === undefined) {
 96 | 					console.warn(`Query parameter ${key} is undefined, skipping`);
 97 | 					continue;
 98 | 				}
 99 | 				if (value) {
100 | 					query_params.append(key, value.toString());
101 | 				}
102 | 			}
103 | 		}
104 | 
105 | 		let baseUrl: string | undefined;
106 | 
107 | 		if (typeof window === "undefined") {
108 | 			baseUrl = undefined;
109 | 		} else {
110 | 			baseUrl = window.location.origin;
111 | 		}
112 | 
113 | 		if (typeof window !== "undefined" && !baseUrl) {
114 | 			throw new Error(
115 | 				"Unable to determine base URL, Please provide it in the constructor",
116 | 			);
117 | 		}
118 | 
119 | 		const url = `${baseUrl ?? ""}${updatedEndpoint}${query_params.size > 0 ? `?${query_params.toString()}` : ""}`;
120 | 
121 | 		const response = (await this.fetchFn(url, {
122 | 			body: JSON.stringify(body),
123 | 			method: method as string,
124 | 		})) as ExtendedResponse<M, EP>;
125 | 
126 | 		if (!response.ok) {
127 | 			const errorResponse = await response.json();
128 | 			response.error = { [response.status]: errorResponse } as ErrorResponse<
129 | 				APIPaths[M][EP]
130 | 			>;
131 | 			return response;
132 | 		}
133 | 
134 | 		const responseData = (await response.json()) as SuccessResponse<
135 | 			APIPaths[M][EP]
136 | 		>;
137 | 
138 | 		response.data = responseData;
139 | 		response.isOk = function (
140 | 			this: ExtendedResponse<M, EP>,
141 | 		): this is ExtendedResponse<M, EP> & {
142 | 			data: SuccessResponse<APIPaths[M][EP]>;
143 | 			error: undefined;
144 | 		} {
145 | 			return this.ok && !!this.data && !this.error;
146 | 		};
147 | 
148 | 		response.okOrThrow = () => {
149 | 			if (!response.ok || !response.data || response.error) {
150 | 				throw new Error(
151 | 					response.error &&
152 | 						typeof response.error === "object" &&
153 | 						"message" in response.error &&
154 | 						typeof response.error.message === "string"
155 | 						? response.error.message
156 | 						: JSON.stringify(response.error),
157 | 				);
158 | 			}
159 | 			return response.data;
160 | 		};
161 | 		return response;
162 | 	}
163 | 
164 | 	get<EP extends keyof GET>(endpoint: EP, parameters: Params<GET[EP]>) {
165 | 		return this.request(endpoint, "GET", parameters);
166 | 	}
167 | 
168 | 	post<EP extends keyof POST>(endpoint: EP, parameters: Params<POST[EP]>) {
169 | 		return this.request(endpoint, "POST", parameters);
170 | 	}
171 | 
172 | 	put<EP extends keyof PUT>(endpoint: EP, parameters: Params<PUT[EP]>) {
173 | 		return this.request(endpoint, "PUT", parameters);
174 | 	}
175 | 
176 | 	patch<EP extends keyof PATCH>(endpoint: EP, parameters: Params<PATCH[EP]>) {
177 | 		return this.request(endpoint, "PATCH", parameters);
178 | 	}
179 | 
180 | 	delete<EP extends keyof DELETE>(
181 | 		endpoint: EP,
182 | 		parameters: Params<DELETE[EP]>,
183 | 	) {
184 | 		return this.request(endpoint, "DELETE", parameters);
185 | 	}
186 | }
187 | 


--------------------------------------------------------------------------------
/src/assets/docs/+page.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |   import { onMount } from "svelte";
 3 |   import { SwaggerUIBundle } from "swagger-ui-dist";
 4 |   import "swagger-ui-dist/swagger-ui.css";
 5 | 
 6 |   onMount(async () => {
 7 |     SwaggerUIBundle({
 8 |       url: "/api/schemas/swagger.json",
 9 |       dom_id: "#swagger-ui-container",
10 |       defaultModelsExpandDepth: 0,
11 |     });
12 |   });
13 | </script>
14 | 
15 | <svelte:head>
16 |   <title>SwaggerUI</title>
17 | </svelte:head>
18 | 
19 | <div id="swagger-ui-container"></div>
20 | 


--------------------------------------------------------------------------------
/src/assets/interfaces.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | export interface Get<
 3 |     PathParams = { [key: string]: unknown },
 4 |     QueryParams = { [key: string]: unknown },
 5 |     Output = { [key: string]: unknown }
 6 | > {
 7 |     parameters: {
 8 |         path?: PathParams;
 9 |         query: QueryParams;
10 |     };
11 |     responses: {
12 |         200: Output;
13 |     };
14 | }
15 | 
16 | export interface Post<
17 |     PathParams = { [key: string]: unknown },
18 |     RequestBody = { [key: string]: unknown },
19 |     QueryParams = { [key: string]: unknown },
20 |     Output = { [key: string]: unknown }
21 | > {
22 |     parameters: {
23 |         path?: PathParams;
24 |         body: RequestBody;
25 |         query?: QueryParams;
26 |     };
27 |     responses: {
28 |         200: Output;
29 |     };
30 | }
31 | 
32 | export interface Put<
33 |     PathParams = { [key: string]: unknown },
34 |     RequestBody = { [key: string]: unknown },
35 |     QueryParams = { [key: string]: unknown },
36 |     Output = { [key: string]: unknown }
37 | > {
38 |     parameters: {
39 |         path?: PathParams;
40 |         body: RequestBody;
41 |         query?: QueryParams;
42 |     };
43 |     responses: {
44 |         200: Output;
45 |     };
46 | }
47 | 
48 | export interface Delete<
49 |     PathParams = { [key: string]: unknown },
50 |     QueryParams = { [key: string]: unknown },
51 |     Output = { [key: string]: unknown }
52 | > {
53 |     parameters: {
54 |         path?: PathParams;
55 |         query: QueryParams;
56 |     };
57 |     responses: {
58 |         200: Output;
59 |     };
60 | }
61 | 
62 | export interface Patch<
63 |     PathParams = { [key: string]: unknown },
64 |     RequestBody = { [key: string]: unknown },
65 |     QueryParams = { [key: string]: unknown },
66 |     Output = { [key: string]: unknown }
67 | > {
68 |     parameters: {
69 |         path?: PathParams;
70 |         body: RequestBody;
71 |         query?: QueryParams;
72 |     };
73 |     responses: {
74 |         200: Output;
75 |     };
76 | }
77 | 
78 | export type RecursiveJSONSchema = {
79 |     description?: string
80 |     type: string
81 |     const?: string
82 |     format?: string
83 |     properties?: {
84 |         [key: string]: RecursiveJSONSchema
85 |     }
86 |     items?: RecursiveJSONSchema
87 |     required?: string[]
88 | }


--------------------------------------------------------------------------------
/src/bin.ts:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | import { runAll } from './index.js';
3 | import * as path from 'node:path';
4 | 
5 | console.log(import.meta.dirname);
6 | runAll();
7 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
  1 | import * as path from "node:path";
  2 | import * as fs from "node:fs";
  3 | import prompts, { type PromptObject } from "prompts";
  4 | import { log } from "./utils/logger.js";
  5 | import { main } from "./generator.js";
  6 | import { performance } from "node:perf_hooks";
  7 | import ora, { oraPromise } from "ora";
  8 | import { spinner } from "./utils/ux/spinner.js";
  9 | import { ChildProcess, execSync } from "node:child_process";
 10 | import { checkAndInstallPackage } from "./utils/check_package.js";
 11 | 
 12 | const separator = "--------------------------------------";
 13 | 
 14 | interface ScriptArgs {
 15 | 	framework: string;
 16 | 	input: string;
 17 | 	staticFolder: string;
 18 | 	out: string;
 19 | 	docs: string;
 20 | 	tsconfig: string;
 21 | 	logLevel?: number;
 22 | 	filter?: string | null;
 23 | 	telemetry: boolean;
 24 | }
 25 | 
 26 | const defaultArgs: ScriptArgs = {
 27 | 	framework: "sveltekit",
 28 | 	input: "src/routes/api",
 29 | 	out: "src/lib/api",
 30 | 	docs: "src/routes/docs",
 31 | 	staticFolder: "static",
 32 | 	tsconfig: "tsconfig.json",
 33 | 	logLevel: 5,
 34 | 	filter: null,
 35 | 	telemetry: true,
 36 | };
 37 | 
 38 | const isInit = process.argv[2] === "init";
 39 | 
 40 | // Get the command-line arguments
 41 | const args: string[] = process.argv.slice(3);
 42 | 
 43 | function parseArgs(rawArgs: string[]): ScriptArgs {
 44 | 	const svetchrcExists = fs.existsSync(".svetchrc");
 45 | 	const parsedArgs = svetchrcExists ? readSvetchrc() : {};
 46 | 
 47 | 	for (let i = 0; i < rawArgs.length; i += 2) {
 48 | 		const argName = rawArgs[i]?.replace("--", "");
 49 | 		const argValue = rawArgs[i + 1];
 50 | 		if (argName && argValue) {
 51 | 			parsedArgs[argName] = argValue;
 52 | 		}
 53 | 	}
 54 | 
 55 | 	return { ...defaultArgs, ...parsedArgs };
 56 | }
 57 | 
 58 | const workingDir = process.cwd();
 59 | export async function initSvetchrc() {
 60 | 	console.log(`
 61 |   #  ███████╗██╗   ██╗███████╗████████╗ ██████╗██╗  ██╗
 62 |   #  ██╔════╝██║   ██║██╔════╝╚══██╔══╝██╔════╝██║  ██║
 63 |   #  ███████╗██║   ██║█████╗     ██║   ██║     ███████║
 64 |   #  ╚════██║╚██╗ ██╔╝██╔══╝     ██║   ██║     ██╔══██║
 65 |   #  ███████║ ╚████╔╝ ███████╗   ██║   ╚██████╗██║  ██║
 66 |   #  ╚══════╝  ╚═══╝  ╚══════╝   ╚═╝    ╚═════╝╚═╝  ╚═╝
 67 |   #   NEVER TYPE YOUR TYPES TWICE
 68 |       Send any feedback or issues here 👉 https://github.com/Bewinxed/svetch/
 69 | `);
 70 | 
 71 | 	if (fs.existsSync(".svetchrc")) {
 72 | 		fs.renameSync(".svetchrc", ".svetchrc.backup");
 73 | 		spinner.warn(
 74 | 			"Existing .svetchrc file has been renamed to .svetchrc.backup",
 75 | 		);
 76 | 	}
 77 | 
 78 | 	const questions: PromptObject[] = [
 79 | 		{
 80 | 			type: "text",
 81 | 			name: "input",
 82 | 			message: "Which folder would you like svetch to scan for API routes?",
 83 | 			initial: defaultArgs.input,
 84 | 		},
 85 | 		{
 86 | 			type: "text",
 87 | 			name: "out",
 88 | 			message:
 89 | 				"Where would you like svetch to output the generated API files? (The Client/Types/Zod Schemas will be written here)",
 90 | 			initial: defaultArgs.out,
 91 | 		},
 92 | 		{
 93 | 			type: "text",
 94 | 			name: "docs",
 95 | 			message:
 96 | 				"Where would you like svetch to output the generated API documentation?",
 97 | 			initial: defaultArgs.docs,
 98 | 		},
 99 | 		{
100 | 			type: "text",
101 | 			name: "staticFolder",
102 | 			message: "Where is your static folder located?",
103 | 			initial: defaultArgs.staticFolder,
104 | 		},
105 | 	];
106 | 
107 | 	const response = await prompts(questions);
108 | 
109 | 	fs.writeFileSync(
110 | 		".svetchrc",
111 | 		JSON.stringify({ ...defaultArgs, ...response }, null, 2),
112 | 	);
113 | 
114 | 	spinner.start(
115 | 		`Svetch configuration written to ${path.resolve(workingDir, ".svetchrc")}`,
116 | 	);
117 | }
118 | 
119 | function readSvetchrc() {
120 | 	try {
121 | 		const config_file = fs.readFileSync(".svetchrc", "utf8");
122 | 		return JSON.parse(config_file) as ScriptArgs;
123 | 	} catch (error) {
124 | 		console.error("Error reading .svetchrc file:", error);
125 | 		process.exit(1);
126 | 	}
127 | }
128 | 
129 | export async function runAll() {
130 | 	const start = performance.now();
131 | 
132 | 	// check if swagger-ui-dist is installed
133 | 	checkAndInstallPackage("swagger-ui-dist", true);
134 | 
135 | 	try {
136 | 		if (isInit || !fs.existsSync(path.resolve(workingDir, ".svetchrc"))) {
137 | 			await initSvetchrc();
138 | 		}
139 | 		const spinner = ora({ color: "yellow" }).start("Starting task");
140 | 		await main(parseArgs(args));
141 | 		const end = performance.now();
142 | 		spinner.succeed(`Task completed in ${(end - start).toFixed(2)}ms`);
143 | 	} catch (error) {
144 | 		spinner.fail(`Task failed: ${(error as Error).message}`);
145 | 		console.error(error);
146 | 		throw error;
147 | 	} finally {
148 | 		process.exit(0);
149 | 	}
150 | }
151 | 


--------------------------------------------------------------------------------
/src/init.ts:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env tsx
2 | 
3 | import { initSvetchrc } from './index.js';
4 | 
5 | initSvetchrc();
6 | 


--------------------------------------------------------------------------------
/src/lib/parsers/express/responses.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Bewinxed/svetch/8031f56ac2e947f9e09dc2671312c7d794e7baa9/src/lib/parsers/express/responses.ts


--------------------------------------------------------------------------------
/src/lib/parsers/sveltekit/responses.ts:
--------------------------------------------------------------------------------
 1 | import type { ErrorDetails } from "../../../types/core.js";
 2 | import { mock_node } from "../../../utils/helpers/mock.js";
 3 | import { Node, SyntaxKind, type CallExpression } from "ts-morph";
 4 | 
 5 | export function extract_kit_error(
 6 | 	node: CallExpression,
 7 | 	// biome-ignore lint/suspicious/noExplicitAny: This is a generic function
 8 | ): ErrorDetails<any> | null {
 9 | 	const expression = node.getExpression();
10 | 	if (Node.isIdentifier(expression) && expression.getText() === "error") {
11 | 		const [status, initializer] = node.getArguments();
12 | 		if (Node.isNumericLiteral(status) && Node.isStringLiteral(initializer)) {
13 | 			// biome-ignore lint/style/noNonNullAssertion: This is a mock node
14 | 			const updated_node = mock_node(
15 | 				node,
16 | 				`
17 |             const error = {
18 |                 message: "${initializer.getLiteralValue()}"
19 |             }
20 |             `.replace("'", "\\'"),
21 | 			).getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression)!;
22 | 			return {
23 | 				status: status.getLiteralValue(),
24 | 				type_string: `
25 |                 {
26 |                     message: "${initializer.getLiteralValue()}"
27 |                 }
28 |                 `,
29 | 				node: updated_node,
30 | 			};
31 | 		}
32 | 	}
33 | 	return null;
34 | }
35 | 


--------------------------------------------------------------------------------
/src/routes/+page.server.ts:
--------------------------------------------------------------------------------
 1 | export const actions: Actions = {
 2 |     edit_profile: async ({ request, locals, fetch }) => {
 3 | 		const session = await locals.auth.validate()
 4 | 
 5 | 		if (!session) {
 6 | 			return fail(401, { message: "You're not logged in" })
 7 | 		}
 8 | 
 9 | 		const data = await request.formData()
10 | 
11 |         const payload = {
12 |             age: parseInt(data.get('age') as string) || undefined,
13 |             gender: (data.get('gender') as string) || undefined,
14 |             height: parseInt(data.get('height') as string) || undefined,
15 |             weight: parseInt(data.get('weight') as string) || undefined,
16 |             activityLevel: (data.get('activity_level') as string) || undefined,
17 |             goal: (data.get('goal') as string) || undefined,
18 |             goalWeight: parseInt(data.get('goal_weight') as string) || undefined,
19 |             allergies: {
20 |                 createMany: {
21 |                     data: ((data.get('allergies') as string) ?? '').split(',').map((allergy) => {
22 |                         return {
23 |                             name: allergy
24 |                         }
25 |                     })
26 |                 }
27 |             },
28 |             comorbidities: {
29 |                 createMany: {
30 |                     data: ((data.get('comorbidities') as string) ?? '').split(',').map((comorbidity) => {
31 |                         return {
32 |                             name: comorbidity
33 |                         }
34 |                     })
35 |                 }
36 |             }
37 |         }
38 | 
39 | 		return {
40 |             status: 200,
41 |             body: {
42 |                 message: 'Profile updated successfully',
43 |             }
44 |         }
45 | 	}
46 | };


--------------------------------------------------------------------------------
/src/routes/+page.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 | 	import { Svetch } from "../lib/api/client.js";
 3 | 
 4 |     const svetch = new Svetch()
 5 | 
 6 |     const result = svetch.post("/api/prisma/:id", {
 7 |         path: {
 8 |             id: "1"
 9 |         },
10 |         body: {
11 |         }
12 |     }).then((res) => res.okOrThrow())
13 | </script>


--------------------------------------------------------------------------------
/src/routes/api/prisma/[id]/+server.ts:
--------------------------------------------------------------------------------
  1 | import type { Prisma } from "@prisma/client";
  2 | import type { Session } from "lucia";
  3 | 
  4 | export type SolanaSignInInput = {
  5 | 	account: {
  6 | 		address: string;
  7 | 		icon: string;
  8 | 		label: string;
  9 | 	};
 10 | 	proof: string;
 11 | };
 12 | 
 13 | export type SerializedSolanaSignInOutput = {
 14 | 	account: {
 15 | 		address: string;
 16 | 		icon: string;
 17 | 		label: string;
 18 | 	};
 19 | 	signature: string;
 20 | };
 21 | /**
 22 |  * @tsoaModel
 23 |  */
 24 | type Document = {};
 25 | export const POST = async ({
 26 | 	getClientAddress,
 27 | 	locals,
 28 | 	params,
 29 | 	request,
 30 | 	url
 31 | }) => {
 32 | 	let session = await locals.auth.validate();
 33 | 
 34 | 	const application = await prisma.application
 35 | 		.findFirstOrThrow({
 36 | 			include: {
 37 | 				app_role: {
 38 | 					orderBy: {
 39 | 						created_at: 'asc'
 40 | 					}
 41 | 				},
 42 | 				authentication_rule: {
 43 | 					where: {
 44 | 						provider: 'solana'
 45 | 					}
 46 | 				}
 47 | 			},
 48 | 			where: {
 49 | 				id: params.app_id
 50 | 			}
 51 | 		})
 52 | 		.catch(() => {
 53 | 			throw error(
 54 | 				404,
 55 | 				'Application not found, Or Solana OAuth not enabled for this application'
 56 | 			);
 57 | 		});
 58 | 
 59 | 	const state = url.searchParams.get('state');
 60 | 
 61 | 	if (!state) {
 62 | 		throw error(400, 'Missing state');
 63 | 	}
 64 | 
 65 | 	const payload = (await request.json()) as {
 66 | 		input: SolanaSignInInput;
 67 | 		output: SerializedSolanaSignInOutput;
 68 | 	};
 69 | 
 70 | 	const {
 71 | 		output: {
 72 | 			account: { publicKey: public_key },
 73 | 			signature
 74 | 		}
 75 | 	} = payload;
 76 | 
 77 | 	if (!public_key) {
 78 | 		throw new Error('Invalid public key');
 79 | 	}
 80 | 
 81 | 	const authRequest = await verifyMessage(url, state, payload);
 82 | 
 83 | 	const { access_token, access_token_expires_in, refresh_token } =
 84 | 		await create_session_tokens({
 85 | 			account_id: public_key,
 86 | 			application,
 87 | 			date: authRequest.created_at,
 88 | 			proof: signature
 89 | 		});
 90 | 
 91 | 	let user: Prisma.UserGetPayload<{
 92 | 		include: {
 93 | 			key: true;
 94 | 		};
 95 | 	}> | null = null;
 96 | 
 97 | 	try {
 98 | 		if (session) {
 99 | 			user = await handle_existing_session({
100 | 				application,
101 | 				provider: 'solana',
102 | 				provider_account_id: public_key,
103 | 				provider_user: {
104 | 					email: payload.output.account.address,
105 | 					id: public_key,
106 | 					image: payload.output.account.icon ?? '',
107 | 					name: payload.output.account.label ?? 'Unnamed'
108 | 				},
109 | 				session
110 | 			});
111 | 		} else {
112 | 			user = await handle_no_session({
113 | 				application,
114 | 				provider: 'solana',
115 | 				provider_account_id: public_key,
116 | 				provider_user: {
117 | 					email: payload.output.account.address,
118 | 					id: public_key,
119 | 					image: payload.output.account.icon ?? '',
120 | 					name: payload.output.account.label ?? 'Unnamed'
121 | 				}
122 | 			});
123 | 		}
124 | 	} catch (e) {
125 | 		if (e instanceof Error) {
126 | 			console.log(e);
127 | 			throw error(500, e.message);
128 | 		}
129 | 	}
130 | 
131 | 	if (!user) {
132 | 		throw error(500, 'User not found nor created');
133 | 	}
134 | 
135 | 	await prisma.authRequest.update({
136 | 		data: {
137 | 			access_token,
138 | 			access_token_expires_in,
139 | 			ip_address: getClientAddress(),
140 | 			provider_access_token: access_token,
141 | 			provider_refresh_token: refresh_token,
142 | 			refresh_token,
143 | 			signature,
144 | 			user_id: user.id
145 | 		},
146 | 		where: {
147 | 			id: authRequest.id
148 | 		}
149 | 	});
150 | 
151 | 	session = await auth.createSession({
152 | 		attributes: {
153 | 			access_token,
154 | 			access_token_expires_in,
155 | 			application_id: authRequest?.application_id,
156 | 			auth_request_id: authRequest?.id,
157 | 			provider_account_id: public_key,
158 | 			refresh_token
159 | 		},
160 | 		userId: user.id
161 | 	});
162 | 
163 | 	locals.auth.setSession(session);
164 | 
165 | 	const results = session as Session
166 | 
167 | 	return json(results);
168 | };
169 | 
170 | /**
171 |  * @tsoaModel
172 |  */
173 | type UnExportedType = {
174 | 	id: string;
175 | 	create: Prisma.UserGetPayload<object>;
176 | };
177 | 
178 | export const PATCH = async ({ request, params, url }) => {
179 | 	const id = params.id as string;
180 | 	const string_param = url.searchParams.get("query") as string;
181 | 	const number_param = url.searchParams.get("number") as number;
182 | 	const payload = {} as Prisma.UserUpdateWithoutPostsInput;
183 | 
184 | 	const results = {} as Prisma.PostGetPayload<{
185 | 		include: {
186 | 			author: true;
187 | 		};
188 | 	}>;
189 | 
190 | 	if (ree) {
191 | 		return new Response({} as UnExportedType);
192 | 	}
193 | 
194 | 	if (blah) {
195 | 		const posts = [] as Prisma.PostGetPayload<{
196 | 			include: {
197 | 				author: true;
198 | 			};
199 | 		}>[];
200 | 		return json(posts);
201 | 	}
202 | 
203 | 	if (a) {
204 | 		return new Response(`${url}${params ? `&${params.toString()}` : ""}`, {
205 | 			headers: {
206 | 				"content-type": "text/plain",
207 | 			},
208 | 		});
209 | 	}
210 | 
211 | 	if (obj) {
212 | 		return json({
213 | 			owo: "what's this?",
214 | 			id: params.id,
215 | 		});
216 | 	}
217 | 
218 | 	if (json) {
219 | 		return new Response(
220 | 			JSON.stringify(sessions as Prisma.PostGetPayload<object>[], (_, value) =>
221 | 				typeof value === "bigint" ? value.toString() : value,
222 | 			),
223 | 		);
224 | 	}
225 | 
226 | 	if (notok) {
227 | 		return new Response("Not OK", {
228 | 			status: 400,
229 | 		});
230 | 	}
231 | 
232 | 	if (nah) {
233 | 		throw error(400, "Bad Request");
234 | 	} else if (blah) {
235 | 		return error(500, "Internal Server Error");
236 | 	}
237 | 
238 | 	if (lucia) {
239 | 		const session = {} as Session;
240 | 		return json(session.userId);
241 | 	}
242 | 	return json(results);
243 | };
244 | 
245 | export const GET = async ({ params, url }) => {
246 | 	const id = params.id as string;
247 | 	const string_param = url.searchParams.get("query") as string;
248 | 	const number_param = url.searchParams.get("number") as number;
249 | 
250 | 	return json({'uwu'});
251 | };
252 | 


--------------------------------------------------------------------------------
/src/routes/docs/+page.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |   import { onMount } from "svelte";
 3 |   import { SwaggerUIBundle } from "swagger-ui-dist";
 4 |   import "swagger-ui-dist/swagger-ui.css";
 5 | 
 6 |   onMount(async () => {
 7 |     SwaggerUIBundle({
 8 |       url: "/api/schemas/swagger.json",
 9 |       dom_id: "#swagger-ui-container",
10 |       defaultModelsExpandDepth: 0,
11 |     });
12 |   });
13 | </script>
14 | 
15 | <svelte:head>
16 |   <title>SwaggerUI</title>
17 | </svelte:head>
18 | 
19 | <div id="swagger-ui-container"></div>
20 | 


--------------------------------------------------------------------------------
/src/telemetry.json:
--------------------------------------------------------------------------------
1 | {"_id":"8130949a-af73-44e0-9507-49d0021a9d9e","project":"svetch","timestamp":1721821157077,"data":{"session_id":"f9f82589-0ad6-45f3-a306-f08c26739ced","script_name":"svetch","operating_system":"linux","node_version":"v21.6.0","npm_version":"unknown","encountered_errors":false,"error_messages":[],"processed_files_count":0,"generated_lines_of_code":0,"processed_endpoints":{"POST":0,"GET":0,"PUT":0,"PATCH":0,"DELETE":0}}}


--------------------------------------------------------------------------------
/src/types/core.ts:
--------------------------------------------------------------------------------
 1 | import type { Node } from "ts-morph";
 2 | 
 3 | export interface FormattedType {
 4 | 	typeString?: string;
 5 | 	imports?: Set<string>;
 6 | 	jsdoc?: string;
 7 | }
 8 | 
 9 | export interface ErrorDetails<T extends Node> {
10 | 	status: number;
11 | 	type_string?: string;
12 | 	node: T;
13 | }
14 | 
15 | export type EndpointDefinition = {
16 | 	parameters: {
17 | 		body?: FormattedType;
18 | 		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
19 | 		path?: Record<string, any>;
20 | 		query?: Record<string, FormattedType>;
21 | 	};
22 | 	responses: Partial<Record<number, FormattedType[]>>;
23 | 	errors: Record<string, FormattedType[]>;
24 | 	docs?: string;
25 | 	imports: Set<string>;
26 | };
27 | 
28 | export type MethodMap = Map<HTTP_METHOD, EndpointDefinition>;
29 | 
30 | export type Endpoints = Map<string, MethodMap>;
31 | 
32 | export type HTTP_METHOD =
33 | 	| "GET"
34 | 	| "POST"
35 | 	| "PUT"
36 | 	| "DELETE"
37 | 	| "PATCH"
38 | 	| "HEAD"
39 | 	| "OPTIONS"
40 | 	| "TRACE"
41 | 	| "CONNECT";
42 | 
43 | export type ScriptArgs = {
44 | 	framework: string;
45 | 	input: string;
46 | 	staticFolder: string;
47 | 	out: string;
48 | 	docs: string;
49 | 	tsconfig: string;
50 | 	logLevel?: number;
51 | 	filter?: string | null;
52 | 	telemetry: boolean;
53 | };
54 | 


--------------------------------------------------------------------------------
/src/types/telemetry.ts:
--------------------------------------------------------------------------------
 1 | export type Telemetry = {
 2 | 	_id: string;
 3 | 	project: string;
 4 | 	timestamp: number;
 5 | 	data: {
 6 | 		session_id: string; // Unique identifier for the user's session (optional, if the script is used publicly)
 7 | 
 8 | 		// Script information
 9 | 		script_name: string; // The name of the code generator script
10 | 		script_version?: string; // The version of the code generator script
11 | 
12 | 		// User environment
13 | 		operating_system: string; // The user's operating system (e.g., Windows, macOS, Linux)
14 | 		node_version: string; // The version of Node.js the user is using
15 | 		npm_version: string; // The version of npm the user is using
16 | 
17 | 		// Code generation details
18 | 		processed_files_count: number; // The number of files generated by the script
19 |         generated_lines_of_code: number; // The total number of lines of code generated
20 |         processed_endpoints: Record<string, number>
21 | 
22 | 		// Error tracking (if applicable)
23 | 		encountered_errors: boolean; // Whether any errors were encountered during code generation
24 | 		error_messages: string[]; // An array of error messages, if errors occurred
25 | 
26 | 		// Custom events and properties (add more as needed)
27 | 		custom_events?: {
28 | 			event_name: string;
29 | 			event_properties?: Record<string, any>; // Additional properties specific to the custom event
30 | 		}[];
31 | 	};
32 | };


--------------------------------------------------------------------------------
/src/utils/check_package.ts:
--------------------------------------------------------------------------------
 1 | import { execSync } from "node:child_process";
 2 | 
 3 | export function checkAndInstallPackage(
 4 | 	packageName: string,
 5 | 	devDependency = false,
 6 | ) {
 7 | 	try {
 8 | 		// Check if the package is installed
 9 | 		execSync(`npm list ${packageName} --depth=0 --json`, { stdio: "pipe" });
10 | 		// console.log(`${packageName} is already installed.`);
11 | 	} catch (error) {
12 | 		// If the package is not found, install it
13 | 		console.log(`${packageName} is not installed. Installing...`);
14 | 		const installCommand = `npm install ${devDependency ? "-D" : ""} ${packageName}`;
15 | 		try {
16 | 			execSync(installCommand, { stdio: "inherit" });
17 | 			console.log(`${packageName} has been installed successfully.`);
18 | 		} catch (installError) {
19 | 			if (installError instanceof Error) {
20 | 				console.error(
21 | 					`Failed to install ${packageName}:`,
22 | 					installError.message,
23 | 				);
24 | 			}
25 | 		}
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/src/utils/endpoint_extractors.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 | 	Node,
  3 | 	type TypeNode,
  4 | 	type TypeChecker,
  5 | 	CallExpression,
  6 | 	SyntaxKind,
  7 | 	NewExpression,
  8 | 	ThrowStatement,
  9 | 	CatchClause,
 10 | 	Identifier,
 11 | 	ObjectLiteralExpression,
 12 | 	StringLiteral,
 13 | 	NumericLiteral,
 14 | 	PropertyAccessExpression,
 15 | 	PropertyAssignment,
 16 | } from "ts-morph";
 17 | import { footprintOfType } from "./svelte-codegen.js";
 18 | import type { ErrorDetails, FormattedType } from "../types/core.js";
 19 | import { extract_kit_error } from "../lib/parsers/sveltekit/responses.js";
 20 | import type { Ora } from "ora";
 21 | import { log_node_with_location, node_text_snippet } from "./logger.js";
 22 | 
 23 | export function extract_payload_node(node: Node) {
 24 | 	if (Node.isVariableDeclaration(node)) {
 25 | 		const initializer = node.getInitializer();
 26 | 
 27 | 		// Check for 'payload =' declaration
 28 | 		if (node.getName() === "payload") {
 29 | 			if (Node.isAsExpression(initializer)) {
 30 | 				return initializer.getTypeNode();
 31 | 			}
 32 | 			return node.getTypeNode();
 33 | 		}
 34 | 
 35 | 		// Check for 'await request.json()' assignment, including with type assertion
 36 | 		if (initializer) {
 37 | 			if (Node.isAwaitExpression(initializer)) {
 38 | 				const awaitedExpression = initializer.getExpression();
 39 | 				if (
 40 | 					Node.isCallExpression(awaitedExpression) &&
 41 | 					awaitedExpression.getExpression().getText() === "request.json"
 42 | 				) {
 43 | 					return node.getTypeNode();
 44 | 				}
 45 | 			} else if (Node.isAsExpression(initializer)) {
 46 | 				const expression = initializer.getExpression();
 47 | 				if (Node.isAwaitExpression(expression)) {
 48 | 					const awaitedExpression = expression.getExpression();
 49 | 					if (
 50 | 						Node.isCallExpression(awaitedExpression) &&
 51 | 						awaitedExpression.getExpression().getText() === "request.json"
 52 | 					) {
 53 | 						return initializer.getTypeNode();
 54 | 					}
 55 | 				} else if (Node.isObjectLiteralExpression(expression)) {
 56 | 					// Handle cases like `{} as SomeType`
 57 | 					return initializer.getTypeNode();
 58 | 				}
 59 | 			}
 60 | 		}
 61 | 	}
 62 | }
 63 | 
 64 | function extractErrorDetails(
 65 | 	node: Node,
 66 | 	framework: string,
 67 | ): ErrorDetails<any> | null {
 68 | 	if (Node.isThrowStatement(node)) {
 69 | 		return extractFromThrowStatement(node);
 70 | 	}
 71 | 	if (Node.isCatchClause(node)) {
 72 | 		return extractFromCatchClause(node);
 73 | 	}
 74 | 	if (Node.isCallExpression(node)) {
 75 | 		return extractFromCallExpression(node, framework);
 76 | 	}
 77 | 	// console.error(node.getKindName(), node.getText());
 78 | 	return null;
 79 | }
 80 | 
 81 | function extractFromThrowStatement(
 82 | 	node: ThrowStatement,
 83 | 	// biome-ignore lint/suspicious/noExplicitAny: This is a generic function
 84 | ): ErrorDetails<any> | null {
 85 | 	const expression = node.getExpression();
 86 | 	if (Node.isNewExpression(expression)) {
 87 | 		const args = expression.getArguments();
 88 | 		if (
 89 | 			args.length >= 2 &&
 90 | 			Node.isNumericLiteral(args[0]) &&
 91 | 			Node.isStringLiteral(args[1])
 92 | 		) {
 93 | 			return {
 94 | 				status: Number(args[0].getLiteralValue()),
 95 | 				node: args[1],
 96 | 			};
 97 | 		}
 98 | 	}
 99 | 	return null;
100 | }
101 | 
102 | // biome-ignore lint/suspicious/noExplicitAny: <explanation>
103 | function extractFromCatchClause(node: CatchClause): ErrorDetails<any> | null {
104 | 	const throwStatement = node
105 | 		.getBlock()
106 | 		.getFirstDescendantByKind(SyntaxKind.ThrowStatement);
107 | 	if (throwStatement) {
108 | 		const result = extractFromThrowStatement(throwStatement);
109 | 		if (result) {
110 | 			const variableDeclaration = node.getVariableDeclaration();
111 | 			if (variableDeclaration) {
112 | 				result.node = variableDeclaration;
113 | 			}
114 | 			return result;
115 | 		}
116 | 	}
117 | 	return null;
118 | }
119 | 
120 | function extractFromCallExpression(
121 | 	node: CallExpression,
122 | 	framework: string,
123 | 	// biome-ignore lint/suspicious/noExplicitAny: This is a generic function
124 | ): ErrorDetails<any> | null {
125 | 	if (framework === "sveltekit" && node.getText().includes("error(")) {
126 | 		return extract_kit_error(node);
127 | 	}
128 | 	const expression = node.getExpression();
129 | 	if (Node.isIdentifier(expression) && expression.getText() === "error") {
130 | 		const args = node.getArguments();
131 | 		if (
132 | 			args.length >= 2 &&
133 | 			Node.isNumericLiteral(args[0]) &&
134 | 			Node.isStringLiteral(args[1])
135 | 		) {
136 | 			return {
137 | 				status: Number(args[0].getLiteralValue()),
138 | 				node: args[1],
139 | 			};
140 | 		}
141 | 	}
142 | 	return null;
143 | }
144 | 
145 | type StatementResult = {
146 | 	status: number;
147 | 	type: FormattedType;
148 | };
149 | 
150 | function processTypeNode(node: Node, typeChecker: TypeChecker): FormattedType {
151 | 	const footprint = footprintOfType({
152 | 		type: typeChecker.getTypeAtLocation(node),
153 | 		node: node,
154 | 		typeChecker: typeChecker,
155 | 	});
156 | 	// console.error(node.getText(), footprint.typeString);
157 | 	// if the type is any
158 | 	if (footprint.typeString === "any") {
159 | 		// console.error(node.getKindName(), node.getText());
160 | 	}
161 | 	return footprint;
162 | }
163 | 
164 | function extract_return_statement(
165 | 	node: Node,
166 | 	typeChecker: TypeChecker,
167 | 	spinner: Ora,
168 | ): StatementResult | undefined {
169 | 	if (Node.isReturnStatement(node)) {
170 | 		const expression = node.getExpression();
171 | 		if (!expression) {
172 | 			spinner.warn(
173 | 				`Detected return statement without expression ${node_text_snippet(
174 | 					node,
175 | 				)}`,
176 | 			);
177 | 			return;
178 | 		}
179 | 		const result = process_expression(expression, typeChecker, spinner);
180 | 		if (!result || !result.resultsDeclaration) {
181 | 			spinner.warn(
182 | 				`Unhandled return statement with type (${expression.getKindName()})
183 | 			in ${log_node_with_location(node)}`,
184 | 			);
185 | 			return;
186 | 		}
187 | 		if (result?.resultsDeclaration) {
188 | 			return {
189 | 				status: result.status,
190 | 				type: processTypeNode(result?.resultsDeclaration, typeChecker),
191 | 			};
192 | 		}
193 | 		spinner.fail(
194 | 			`Unhandled return expression
195 | 	${log_node_with_location(node)}`,
196 | 		);
197 | 	}
198 | }
199 | 
200 | function process_call_expression(
201 | 	expression: CallExpression | NewExpression,
202 | 	typeChecker: TypeChecker,
203 | 	spinner: Ora,
204 | ): {
205 | 	status: number;
206 | 	resultsDeclaration?: Identifier | ObjectLiteralExpression | Node;
207 | } {
208 | 	const result: {
209 | 		status: number;
210 | 		resultsDeclaration?: Identifier | ObjectLiteralExpression | Node;
211 | 	} = {
212 | 		status: 200,
213 | 		resultsDeclaration: undefined,
214 | 	};
215 | 
216 | 	const args = expression.getArguments();
217 | 
218 | 	const first_arg = args.at(0);
219 | 
220 | 	if (first_arg) {
221 | 		if (
222 | 			CallExpression.isCallExpression(first_arg) ||
223 | 			NewExpression.isNewExpression(first_arg)
224 | 		) {
225 | 			return process_call_expression(first_arg, typeChecker, spinner);
226 | 		}
227 | 
228 | 		if (Identifier.isIdentifier(first_arg)) {
229 | 			result.resultsDeclaration = processReturnIdentifier(
230 | 				first_arg,
231 | 				typeChecker,
232 | 			);
233 | 		} else if (StringLiteral) {
234 | 			result.resultsDeclaration = first_arg;
235 | 		} else if (NumericLiteral.isNumericLiteral(first_arg)) {
236 | 			result.status = Number.parseInt(first_arg.getText());
237 | 		} else if (PropertyAccessExpression.isPropertyAccessExpression(first_arg)) {
238 | 			result.resultsDeclaration = first_arg.getNameNode();
239 | 		} else {
240 | 			console.error(
241 | 				"Unhandled first argument type:",
242 | 				first_arg?.getKindName(),
243 | 				first_arg?.getText(),
244 | 			);
245 | 			result.resultsDeclaration = first_arg;
246 | 		}
247 | 	}
248 | 
249 | 	// console.error(
250 | 	// 	"uwu",
251 | 	// 	args.map((arg) => arg.getKindName()),
252 | 	// 	result.resultsDeclaration?.getText(),
253 | 	// );
254 | 
255 | 	const statusArg = args.find((arg) =>
256 | 		ObjectLiteralExpression.isObjectLiteralExpression(arg),
257 | 	);
258 | 	if (
259 | 		statusArg &&
260 | 		ObjectLiteralExpression.isObjectLiteralExpression(statusArg)
261 | 	) {
262 | 		const statusProperty = statusArg.getProperty("status");
263 | 		if (
264 | 			statusProperty &&
265 | 			PropertyAssignment.isPropertyAssignment(statusProperty)
266 | 		) {
267 | 			const initializer = statusProperty.getInitializer();
268 | 			if (initializer) {
269 | 				const statusValue = Number.parseInt(initializer.getText());
270 | 				if (!Number.isNaN(statusValue)) {
271 | 					result.status = statusValue;
272 | 				}
273 | 			}
274 | 		}
275 | 	}
276 | 
277 | 	// console.log(
278 | 	// 	"Returning:",
279 | 	// 	result.status,
280 | 	// 	result.resultsDeclaration?.getKindName(),
281 | 	// );
282 | 	return result;
283 | }
284 | 
285 | function processReturnIdentifier(
286 | 	expression: Identifier,
287 | 	typeChecker: TypeChecker,
288 | ) {
289 | 	const symbol = typeChecker.getSymbolAtLocation(expression);
290 | 	if (symbol) {
291 | 		const declarations = symbol.getDeclarations();
292 | 		return declarations.at(0) as Node;
293 | 	}
294 | }
295 | 
296 | function process_expression(
297 | 	expression: Node,
298 | 	typeChecker: TypeChecker,
299 | 	spinner: Ora,
300 | ) {
301 | 	if (Node.isNewExpression(expression)) {
302 | 		return process_call_expression(expression, typeChecker, spinner);
303 | 	}
304 | 	if (Node.isCallExpression(expression)) {
305 | 		// console.error(
306 | 		// 	`call expression`,
307 | 		// 	expression.getKindName(),
308 | 		// 	expression.getText(),
309 | 		// );
310 | 		return process_call_expression(expression, typeChecker, spinner);
311 | 	}
312 | 	if (Node.isIdentifier(expression)) {
313 | 		return {
314 | 			status: 200,
315 | 			resultsDeclaration: processReturnIdentifier(expression, typeChecker),
316 | 		};
317 | 	}
318 | 	if (Node.isAsExpression(expression)) {
319 | 		console.error("as expression", expression.getExpression().getKindName());
320 | 		return process_expression(expression.getExpression(), typeChecker, spinner);
321 | 	}
322 | 	if (Node.isPropertyAccessExpression(expression)) {
323 | 		console.error(
324 | 			"property access expression",
325 | 			expression.getKindName(),
326 | 			expression.getText(),
327 | 		);
328 | 		return process_expression(expression.getExpression(), typeChecker, spinner);
329 | 	}
330 | 	if (Node.isAwaitExpression(expression)) {
331 | 		return process_expression(expression.getExpression(), typeChecker, spinner);
332 | 	}
333 | 	console.error("unhandled expression", expression.getKindName());
334 | }
335 | 
336 | export function extract_endpoint_response(
337 | 	node: Node,
338 | 	typeChecker: TypeChecker,
339 | 	framework: string,
340 | 	spinner: Ora,
341 | ) {
342 | 	const error_node = extractErrorDetails(node, framework);
343 | 	if (error_node) {
344 | 		return {
345 | 			status: error_node.status,
346 | 			type: error_node.type_string
347 | 				? {
348 | 						typeString: error_node.type_string,
349 | 					}
350 | 				: processTypeNode(error_node.node, typeChecker),
351 | 		};
352 | 	}
353 | 
354 | 	const result =
355 | 		extract_results_declaration(node, typeChecker, spinner) ||
356 | 		extract_return_statement(node, typeChecker, spinner);
357 | 	if (result) {
358 | 		return {
359 | 			status: result.status,
360 | 			type: result.type,
361 | 		};
362 | 	}
363 | }
364 | 
365 | function extract_results_declaration(
366 | 	node: Node,
367 | 	typeChecker: TypeChecker,
368 | 	spinner: Ora,
369 | ): StatementResult | undefined {
370 | 	if (
371 | 		Node.isVariableDeclaration(node) &&
372 | 		(node.getName() === "result" || node.getName() === "results")
373 | 	) {
374 | 		const initializer = node.getInitializer();
375 | 		if (!initializer) {
376 | 			spinner.fail(
377 | 				`Unhandled (results =) statement, please report this to the developer, ${node_text_snippet(
378 | 					node,
379 | 				)}, of type ${node?.getKindName()}`,
380 | 			);
381 | 			return;
382 | 		}
383 | 		return {
384 | 			status: 200,
385 | 			type: processTypeNode(initializer, typeChecker),
386 | 		};
387 | 	}
388 | }
389 | 
390 | export function extract_query_parameters(node: Node, typeChecker: TypeChecker) {
391 | 	const queryParameters: Record<string, FormattedType> = {};
392 | 	const searchParamsVariables = new Set<string>();
393 | 	if (Node.isVariableDeclaration(node)) {
394 | 		const initializer = node.getInitializer();
395 | 
396 | 		if (initializer && Node.isPropertyAccessExpression(initializer)) {
397 | 			const expression = initializer.getExpression();
398 | 			const property = initializer.getName();
399 | 
400 | 			if (expression.getText() === "url" && property === "searchParams") {
401 | 				const variableName = node.getName();
402 | 				searchParamsVariables.add(variableName);
403 | 			}
404 | 		}
405 | 	}
406 | 
407 | 	if (Node.isCallExpression(node) || Node.isElementAccessExpression(node)) {
408 | 		// Detect usage of url.searchParams.get(x) or variable.get(x) or variable[x]
409 | 		const expression = node.getExpression();
410 | 
411 | 		if (Node.isPropertyAccessExpression(expression)) {
412 | 			const object = expression.getExpression();
413 | 			const property = expression.getName();
414 | 
415 | 			if (
416 | 				(object.getText() === "url.searchParams" && property === "get") ||
417 | 				(searchParamsVariables.has(object.getText()) && property === "get")
418 | 			) {
419 | 				const args = node.getArguments();
420 | 
421 | 				if (args.length > 0 && Node.isStringLiteral(args[0])) {
422 | 					const queryParameterName = args[0].getLiteralText();
423 | 					const paramType = typeChecker
424 | 						.getTypeAtLocation(node.getParent())
425 | 						.getText();
426 | 					queryParameters[queryParameterName] = { typeString: paramType };
427 | 				}
428 | 			}
429 | 		} else if (Node.isElementAccessExpression(expression)) {
430 | 			const expressionName = expression.getExpression().getText();
431 | 
432 | 			if (searchParamsVariables.has(expressionName)) {
433 | 				const argumentExpression = expression.getArgumentExpression();
434 | 				if (argumentExpression && Node.isStringLiteral(argumentExpression)) {
435 | 					const queryParameterName = argumentExpression.getLiteralText();
436 | 					if (!queryParameters[queryParameterName]) {
437 | 						queryParameters[queryParameterName] = {};
438 | 					}
439 | 					const paramType = footprintOfType({
440 | 						type: typeChecker.getTypeAtLocation(node),
441 | 						node: node,
442 | 						typeChecker: typeChecker,
443 | 					});
444 | 					queryParameters[queryParameterName].typeString = paramType.typeString;
445 | 					queryParameters[queryParameterName].imports = paramType.imports;
446 | 				}
447 | 			}
448 | 		}
449 | 		return queryParameters;
450 | 	}
451 | 
452 | 	if (Node.isVariableDeclaration(node)) {
453 | 		// Get the type of the constant when the query string is assigned to it
454 | 		const initializer = node.getInitializer();
455 | 
456 | 		if (
457 | 			initializer &&
458 | 			(Node.isCallExpression(initializer) ||
459 | 				Node.isElementAccessExpression(initializer))
460 | 		) {
461 | 			const expression = initializer.getExpression();
462 | 
463 | 			if (Node.isPropertyAccessExpression(expression)) {
464 | 				const object = expression.getExpression();
465 | 				const property = expression.getName();
466 | 
467 | 				if (
468 | 					(object.getText() === "url.searchParams" && property === "get") ||
469 | 					(searchParamsVariables.has(object.getText()) && property === "get")
470 | 				) {
471 | 					const variableType = typeChecker.getTypeAtLocation(node);
472 | 					const variableName = node.getName();
473 | 					if (!queryParameters[variableName]) {
474 | 						queryParameters[variableName] = {};
475 | 					}
476 | 					queryParameters[variableName].typeString = variableType.getText();
477 | 				}
478 | 			} else if (Node.isElementAccessExpression(expression)) {
479 | 				const expressionName = expression.getExpression().getText();
480 | 
481 | 				if (searchParamsVariables.has(expressionName)) {
482 | 					const variableType = typeChecker.getTypeAtLocation(node);
483 | 					const variableName = node.getName();
484 | 					if (!queryParameters[variableName]) {
485 | 						queryParameters[variableName] = {};
486 | 					}
487 | 					queryParameters[variableName].typeString = variableType.getText();
488 | 				}
489 | 			}
490 | 		}
491 | 	}
492 | }
493 | 
494 | export function extractPayloadTypeNode(
495 | 	allDeclarations: Node[],
496 | ): TypeNode | undefined {
497 | 	for (const node of allDeclarations) {
498 | 		const payload_node = extract_payload_node(node);
499 | 		if (payload_node) {
500 | 			return payload_node;
501 | 		}
502 | 	}
503 | }
504 | 
505 | export function extractReturnType(
506 | 	allDeclarations: Node[],
507 | 	typeChecker: TypeChecker,
508 | ): TypeNode | null {
509 | 	for (const node of allDeclarations) {
510 | 		if (Node.isReturnStatement(node)) {
511 | 			const expression = node.getExpression();
512 | 			if (expression) {
513 | 				if (
514 | 					Node.isCallExpression(expression) ||
515 | 					Node.isNewExpression(expression)
516 | 				) {
517 | 					// Handle json() or new Response() cases
518 | 					if (
519 | 						expression.getExpression().getText() === "json" ||
520 | 						(Node.isNewExpression(expression) &&
521 | 							expression.getExpression().getText() === "Response")
522 | 					) {
523 | 						const argument = expression.getArguments()[0];
524 | 						if (argument) {
525 | 							return typeChecker.getTypeAtLocation(argument)
526 | 								.compilerType as TypeNode;
527 | 						}
528 | 					}
529 | 				} else if (Node.isIdentifier(expression)) {
530 | 					// Handle case where a variable is returned
531 | 					const symbol = typeChecker.getSymbolAtLocation(expression);
532 | 					if (symbol) {
533 | 						const declarations = symbol.getDeclarations();
534 | 						if (declarations && declarations.length > 0) {
535 | 							const declaration = declarations[0];
536 | 							if (Node.isVariableDeclaration(declaration)) {
537 | 								const type = declaration.getType();
538 | 								return type.compilerType as TypeNode;
539 | 							}
540 | 						}
541 | 					}
542 | 				}
543 | 			}
544 | 		} else if (
545 | 			Node.isVariableDeclaration(node) &&
546 | 			node.getName() === "results"
547 | 		) {
548 | 			// Handle case where 'results' variable is declared
549 | 			return node.getType().compilerType as TypeNode;
550 | 		}
551 | 	}
552 | 
553 | 	return null;
554 | }
555 | 


--------------------------------------------------------------------------------
/src/utils/helpers/mock.ts:
--------------------------------------------------------------------------------
 1 | import { Project, type SourceFile, type Node } from "ts-morph";
 2 | 
 3 | export function mock_node<T extends Node>(
 4 | 	node: T,
 5 | 	source_text: string,
 6 | ): SourceFile {
 7 | 	const project = new Project({
 8 | 		compilerOptions: { allowJs: true },
 9 | 		useInMemoryFileSystem: true,
10 | 	});
11 | 	const source = project.createSourceFile(
12 | 		node.getSourceFile().getFilePath(),
13 | 		source_text,
14 | 	);
15 | 	return source;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/utils/helpers/type.ts:
--------------------------------------------------------------------------------
1 | export function entries<T extends Record<string, unknown>>(obj: T) {
2 | 	return Object.entries(obj) as [keyof T, T[keyof T]][];
3 | }
4 | 


--------------------------------------------------------------------------------
/src/utils/import-utils.ts:
--------------------------------------------------------------------------------
  1 | import * as tsm from "ts-morph";
  2 | 
  3 | export const isJsDocChild = (node: tsm.Node) => {
  4 | 	return node.getAncestors().some((ancestor) => tsm.Node.isJSDoc(ancestor));
  5 | };
  6 | 
  7 | const _nodeIdCache = new Map<tsm.Node, tsm.Node>();
  8 | export const getNodeId = (node: tsm.Node) => {
  9 | 	if (_nodeIdCache.has(node)) {
 10 | 		return _nodeIdCache.get(node)!;
 11 | 	}
 12 | 	for (const id of node.getDescendantsOfKind(tsm.SyntaxKind.Identifier)) {
 13 | 		if (!isJsDocChild(id)) {
 14 | 			_nodeIdCache.set(node, id);
 15 | 			return id;
 16 | 		}
 17 | 	}
 18 | 	return null;
 19 | };
 20 | 
 21 | export class ImportNodeUtil {
 22 | 	#namedImportNodes = new Map<string, string>();
 23 | 	#namedImports = new Map<string, Set<string>>();
 24 | 
 25 | 	#defaultImportNodes = new Map<string, string>();
 26 | 	#defaultImports = new Map<string, Set<string>>();
 27 | 
 28 | 	registerImports(id: tsm.Identifier, sourceFile: tsm.SourceFile) {
 29 | 		const importDecls = sourceFile.getImportDeclarations();
 30 | 
 31 | 		for (const importDecl of importDecls) {
 32 | 			importDecl.getNamedImports().forEach((namedImport, i) => {
 33 | 				if (getNodeId(namedImport).getText() === id.getText()) {
 34 | 					this.#namedImportNodes.set(
 35 | 						getNodeId(namedImport).getText(),
 36 | 						importDecl.getModuleSpecifierValue(),
 37 | 					);
 38 | 				}
 39 | 			});
 40 | 			const importClause = importDecl.getImportClause();
 41 | 			if (importClause) {
 42 | 				if (getNodeId(importClause).getText() === id.getText()) {
 43 | 					this.#defaultImportNodes.set(
 44 | 						getNodeId(importClause).getText(),
 45 | 						importDecl.getModuleSpecifierValue(),
 46 | 					);
 47 | 				}
 48 | 			}
 49 | 		}
 50 | 	}
 51 | 
 52 | 	prepareOutput(declNode: tsm.Node) {
 53 | 		const nodeId = getNodeId(declNode);
 54 | 
 55 | 		if (this.#namedImportNodes.has(nodeId.getText())) {
 56 | 			const importDeclaration = this.#namedImportNodes.get(nodeId.getText())!;
 57 | 			if (!this.#namedImports.has(importDeclaration)) {
 58 | 				this.#namedImports.set(importDeclaration, new Set());
 59 | 			}
 60 | 
 61 | 			this.#namedImports.get(importDeclaration)!.add(nodeId.getText());
 62 | 			return true;
 63 | 		} else if (this.#defaultImportNodes.has(nodeId.getText())) {
 64 | 			const importDeclaration = this.#defaultImportNodes.get(nodeId.getText())!;
 65 | 			if (!this.#defaultImports.has(importDeclaration)) {
 66 | 				this.#defaultImports.set(importDeclaration, new Set());
 67 | 			}
 68 | 
 69 | 			this.#defaultImports.get(importDeclaration)!.add(nodeId.getText());
 70 | 
 71 | 			return true;
 72 | 		}
 73 | 
 74 | 		return false;
 75 | 	}
 76 | 
 77 | 	get output() {
 78 | 		const content: string[] = [];
 79 | 		for (const [importDeclaration, defaultImports] of this.#defaultImports) {
 80 | 			for (const defaultImport of defaultImports) {
 81 | 				content.push(`import ${defaultImport} from "${importDeclaration}"`);
 82 | 			}
 83 | 		}
 84 | 
 85 | 		for (const [importDeclaration, namedImports] of this.#namedImports) {
 86 | 			content.push(
 87 | 				`import { ${[...namedImports].join(
 88 | 					", ",
 89 | 				)} } from "${importDeclaration}";`,
 90 | 			);
 91 | 		}
 92 | 		return content.join("\n");
 93 | 	}
 94 | 
 95 | 	get diagnostics() {
 96 | 		const externNamedImportNodes = [];
 97 | 		for (const [namedImports, importDeclaration] of this.#namedImportNodes) {
 98 | 			externNamedImportNodes.push(
 99 | 				`import { ${namedImports} } from "${importDeclaration}";`,
100 | 			);
101 | 		}
102 | 
103 | 		// external imports that were referenced in d.ts files
104 | 		const externNamedImports = [];
105 | 		for (const [importDeclaration, namedImports] of this.#namedImports) {
106 | 			externNamedImports.push(
107 | 				`import { ${[...namedImports].join(
108 | 					", ",
109 | 				)} } from "${importDeclaration}";`,
110 | 			);
111 | 		}
112 | 
113 | 		const externDefaultImportNodes = [];
114 | 		for (const [defaultImport, importDeclaration] of this.#defaultImportNodes) {
115 | 			externDefaultImportNodes.push(
116 | 				`import ${defaultImport} from "${importDeclaration}";`,
117 | 			);
118 | 		}
119 | 
120 | 		const externDefaultImports = [];
121 | 		for (const [importDeclaration, defaultImports] of this.#defaultImports) {
122 | 			for (const defaultImport of defaultImports) {
123 | 				externDefaultImports.push(
124 | 					`import ${defaultImport} from "${importDeclaration}";`,
125 | 				);
126 | 			}
127 | 		}
128 | 
129 | 		return {
130 | 			externNamedImportNodes,
131 | 			externNamedImports,
132 | 			externDefaultImportNodes,
133 | 			externDefaultImports,
134 | 		};
135 | 	}
136 | }
137 | 


--------------------------------------------------------------------------------
/src/utils/logger.ts:
--------------------------------------------------------------------------------
  1 | import ansiColors from "ansi-colors";
  2 | import type { Node } from "ts-morph";
  3 | 
  4 | class Log {
  5 | 	private console_colors = {
  6 | 		red: "\x1b[31m",
  7 | 		green: "\x1b[32m",
  8 | 		yellow: "\x1b[33m",
  9 | 		blue: "\x1b[34m",
 10 | 		magenta: "\x1b[35m",
 11 | 		cyan: "\x1b[36m",
 12 | 		white: "\x1b[37m",
 13 | 		gray: "\x1b[90m",
 14 | 		reset: "\x1b[0m",
 15 | 		black: "\x1b[30m",
 16 | 	};
 17 | 
 18 | 	private logLevel: number;
 19 | 	private filter: string | null;
 20 | 
 21 | 	constructor(logLevel: number = 5, filter: string | null = null) {
 22 | 		// default log level is 5, which shows all logs
 23 | 		this.logLevel = logLevel;
 24 | 		this.filter = filter;
 25 | 	}
 26 | 
 27 | 	private log(
 28 | 		color: keyof typeof this.console_colors,
 29 | 		nesting: number = 1,
 30 | 		...args: any[]
 31 | 	) {
 32 | 		const formattedArgs = args.map((arg) => {
 33 | 			if (typeof arg === "object") {
 34 | 				// Convert the object to a JSON string with 2-space indentation
 35 | 				let json = JSON.stringify(arg, null, 2);
 36 | 				// Split the JSON string into lines so we can add indentation to each line
 37 | 				let lines = json.split("\n");
 38 | 				// Add the appropriate indentation to each line
 39 | 				let padding = "    ".repeat(nesting);
 40 | 				lines = lines.map((line) => {
 41 | 					// Check if line is a valid JSON string, if so parse it
 42 | 					try {
 43 | 						const parsedJSON = JSON.parse(line.trim());
 44 | 						// If it's parsable, it's a stringified JSON, so we format it with the appropriate indentation
 45 | 						return (
 46 | 							padding +
 47 | 							JSON.stringify(parsedJSON, null, 2).replace(/\n/g, "\n" + padding)
 48 | 						);
 49 | 					} catch (e) {
 50 | 						// If it's not parsable, it's a regular string so we just return it
 51 | 						return padding + line;
 52 | 					}
 53 | 				});
 54 | 				// Join the lines back together into a single string
 55 | 				return lines.join("\n");
 56 | 			} else {
 57 | 				// Non-object arguments are not modified
 58 | 				return arg;
 59 | 			}
 60 | 		});
 61 | 
 62 | 		console.log(
 63 | 			`${this.console_colors[color]}${"    ".repeat(nesting - 1)}${
 64 | 				nesting > 1 ? "↳  " : ""
 65 | 			}${formattedArgs.join(" ")}${this.console_colors.reset}`,
 66 | 		);
 67 | 	}
 68 | 
 69 | 	header(nesting: number = 1, ...args: any[]) {
 70 | 		if (this.logLevel >= 0 && (!this.filter || this.filter === "header")) {
 71 | 			this.log("cyan", nesting, ...args);
 72 | 		}
 73 | 	}
 74 | 
 75 | 	success(nesting: number = 1, ...args: any[]) {
 76 | 		if (this.logLevel >= 1 && (!this.filter || this.filter === "success")) {
 77 | 			this.log("green", nesting, "✅ [SUCCESS]:	", ...args);
 78 | 		}
 79 | 	}
 80 | 
 81 | 	info(nesting: number = 1, ...args: any[]) {
 82 | 		if (this.logLevel >= 2 && (!this.filter || this.filter === "info")) {
 83 | 			this.log("blue", nesting, "🗒 [INFO]:	", ...args);
 84 | 		}
 85 | 	}
 86 | 
 87 | 	warn(nesting: number = 1, ...args: any[]) {
 88 | 		if (this.logLevel >= 3 && (!this.filter || this.filter === "warn")) {
 89 | 			this.log("yellow", nesting, "⚠️ [WARN]:	", ...args);
 90 | 		}
 91 | 	}
 92 | 
 93 | 	error(nesting: number = 1, ...args: any[]) {
 94 | 		// telemetryPayload.data.encountered_errors = true;
 95 | 		// telemetryPayload.data.error_messages.push(args.join(' '));
 96 | 		if (this.logLevel >= 4 && (!this.filter || this.filter === "error")) {
 97 | 			this.log("red", nesting, "🚨 [ERROR]:	", ...args);
 98 | 		}
 99 | 	}
100 | 
101 | 	debug(nesting: number = 1, ...args: any[]) {
102 | 		if (this.logLevel >= 5 && (!this.filter || this.filter === "debug")) {
103 | 			this.log("gray", nesting, "🐛 [DEBUG]:	", ...args);
104 | 		}
105 | 	}
106 | }
107 | 
108 | export const log = new Log();
109 | 
110 | export function log_node_with_location<T extends Node>(node: T) {
111 | 	return `${ansiColors.red("▸")} file:  ${ansiColors.green(
112 | 		node.getSourceFile().getFilePath(),
113 | 	)}${ansiColors.magenta(`:${node.getStartLineNumber()}`)}	
114 | 	${ansiColors.red("▸")} type: ${ansiColors.green(node?.getKindName())}
115 | 	${ansiColors.red("▸")} snippet:
116 | 	${ansiColors.yellow(`------
117 | 	${node.getText()}
118 | 	------`)}`;
119 | }
120 | 
121 | export function node_location_and_line<T extends Node>(declaration: T) {
122 | 	return `${ansiColors.green(
123 | 		absolute_to_relative(declaration.getSourceFile().getFilePath()),
124 | 	)}${ansiColors.magenta(`:${declaration.getStartLineNumber()}`)}`;
125 | }
126 | 
127 | export function absolute_to_relative(path: string) {
128 | 	return path.replace(process.cwd(), "");
129 | }
130 | 
131 | export function node_text_snippet(node: Node) {
132 | 	const text = node.getText();
133 | 	const start = Math.max(0, text.lastIndexOf("\n", 100));
134 | 	const end = Math.min(text.length, text.indexOf("\n", 300));
135 | 	return text.slice(start, end);
136 | }
137 | 


--------------------------------------------------------------------------------
/src/utils/node_utils.ts:
--------------------------------------------------------------------------------
 1 | import type { Node } from "ts-morph";
 2 | import crypto from "node:crypto";
 3 | 
 4 | export function hashNode(node: Node): string {
 5 | 	const hashContent = node.getText();
 6 | 	const hash = crypto.createHash("sha256");
 7 | 	hash.update(hashContent);
 8 | 	return hash.digest("hex");
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/utils/openapi.ts:
--------------------------------------------------------------------------------
  1 | import { OpenAPIV3 } from "openapi-types";
  2 | import * as TJS from "typescript-json-schema";
  3 | import fs from "fs";
  4 | import path from "path";
  5 | 
  6 | export function generateOpenAPISpec(
  7 | 	schemas: Record<string, TJS.Definition>,
  8 | ): OpenAPIV3.Document {
  9 | 	const paths: OpenAPIV3.PathsObject = {};
 10 | 	const components: OpenAPIV3.ComponentsObject = {
 11 | 		schemas: {},
 12 | 	};
 13 | 
 14 | 	for (const [method, schema] of Object.entries(schemas)) {
 15 | 		if (schema.properties) {
 16 | 			for (const [path, pathSchema] of Object.entries(schema.properties)) {
 17 | 				if (!paths[path]) {
 18 | 					paths[path] = {};
 19 | 				}
 20 | 
 21 | 				const operation: OpenAPIV3.OperationObject = {
 22 | 					parameters: createParameters(pathSchema.properties?.parameters),
 23 | 					responses: createResponses(
 24 | 						pathSchema.properties?.responses,
 25 | 						pathSchema.properties?.errors,
 26 | 					),
 27 | 				};
 28 | 
 29 | 				if (method !== "GET") {
 30 | 					operation.requestBody = createRequestBody(
 31 | 						pathSchema.properties?.parameters,
 32 | 					);
 33 | 				}
 34 | 
 35 | 				paths[path][method.toLowerCase() as OpenAPIV3.HttpMethods] = operation;
 36 | 			}
 37 | 		}
 38 | 
 39 | 		// Add schemas to components
 40 | 		if (schema.definitions) {
 41 | 			Object.assign(components.schemas!, schema.definitions);
 42 | 		}
 43 | 	}
 44 | 
 45 | 	return {
 46 | 		openapi: "3.0.0",
 47 | 		info: {
 48 | 			title: "API",
 49 | 			version: "1.0.0",
 50 | 		},
 51 | 		paths,
 52 | 		components,
 53 | 	};
 54 | }
 55 | 
 56 | function createParameters(parameters: any): OpenAPIV3.ParameterObject[] {
 57 | 	const openAPIParameters: OpenAPIV3.ParameterObject[] = [];
 58 | 
 59 | 	if (parameters && parameters.properties) {
 60 | 		if (parameters.properties.path) {
 61 | 			for (const [name, schema] of Object.entries(
 62 | 				parameters.properties.path.properties,
 63 | 			)) {
 64 | 				openAPIParameters.push({
 65 | 					name,
 66 | 					in: "path",
 67 | 					required: true,
 68 | 					schema: schema as OpenAPIV3.SchemaObject,
 69 | 				});
 70 | 			}
 71 | 		}
 72 | 
 73 | 		if (parameters.properties.query) {
 74 | 			for (const [name, schema] of Object.entries(
 75 | 				parameters.properties.query.properties,
 76 | 			)) {
 77 | 				openAPIParameters.push({
 78 | 					name,
 79 | 					in: "query",
 80 | 					schema: schema as OpenAPIV3.SchemaObject,
 81 | 				});
 82 | 			}
 83 | 		}
 84 | 	}
 85 | 
 86 | 	return openAPIParameters;
 87 | }
 88 | 
 89 | function createRequestBody(
 90 | 	parameters: any,
 91 | ): OpenAPIV3.RequestBodyObject | undefined {
 92 | 	if (parameters && parameters.properties && parameters.properties.body) {
 93 | 		return {
 94 | 			content: {
 95 | 				"application/json": {
 96 | 					schema: parameters.properties.body,
 97 | 				},
 98 | 			},
 99 | 		};
100 | 	}
101 | 	return undefined;
102 | }
103 | 
104 | function createResponses(
105 | 	responses: any,
106 | 	errors: any,
107 | ): OpenAPIV3.ResponsesObject {
108 | 	const openAPIResponses: OpenAPIV3.ResponsesObject = {};
109 | 
110 | 	if (responses && responses.properties) {
111 | 		for (const [status, responseSchema] of Object.entries(
112 | 			responses.properties,
113 | 		)) {
114 | 			openAPIResponses[status] = {
115 | 				description: `${status} response`,
116 | 				content: {
117 | 					"application/json": {
118 | 						schema: responseSchema as OpenAPIV3.SchemaObject,
119 | 					},
120 | 				},
121 | 			};
122 | 		}
123 | 	}
124 | 
125 | 	if (errors && errors.properties) {
126 | 		for (const [status, errorSchema] of Object.entries(errors.properties)) {
127 | 			openAPIResponses[status] = {
128 | 				description: `${status} error response`,
129 | 				content: {
130 | 					"application/json": {
131 | 						schema: errorSchema as OpenAPIV3.SchemaObject,
132 | 					},
133 | 				},
134 | 			};
135 | 		}
136 | 	}
137 | 
138 | 	return openAPIResponses;
139 | }
140 | 


--------------------------------------------------------------------------------
/src/utils/svelte-codegen.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 | 	type Type,
  3 | 	Node,
  4 | 	TypeFormatFlags,
  5 | 	type SourceFile,
  6 | 	type Symbol as TsMorphSymbol,
  7 | 	SymbolFlags,
  8 | 	type Signature,
  9 | 	TypeFlags,
 10 | 	type TypeAliasDeclaration,
 11 | 	type TypeChecker,
 12 | 	type ImportDeclaration,
 13 | 	SyntaxKind,
 14 | 	AsExpression,
 15 | 	JSDocableNode,
 16 | } from "ts-morph";
 17 | import type { FormattedType } from "../types/core.js";
 18 | 
 19 | const PRIMITIVE_TYPES = new Set([
 20 | 	"string",
 21 | 	"number",
 22 | 	"boolean",
 23 | 	"undefined",
 24 | 	"null",
 25 | 	"unknown",
 26 | 	"any",
 27 | 	"void",
 28 | 	"date",
 29 | 	"Date",
 30 | 	"bigint",
 31 | ]);
 32 | 
 33 | type FormatFlags = "remove-undefined-from-intersections" | false | "traverse";
 34 | 
 35 | interface FootprintParams {
 36 | 	type: Type;
 37 | 	node: Node;
 38 | 	overrides?: Record<string, string>;
 39 | 	flags?: FormatFlags[];
 40 | 	depth?: number;
 41 | 	typeChecker: TypeChecker;
 42 | }
 43 | 
 44 | const processedTypes = new WeakMap<Type, FormattedType>();
 45 | 
 46 | const DEPTH_LIMIT = 3; // Adjust this value as needed
 47 | const MAX_DEPTH = 15; // Adjust this value as needed
 48 | 
 49 | function handlePrimitiveType(type: Type): FormattedType {
 50 | 	let typeString: string;
 51 | 
 52 | 	switch (true) {
 53 | 		case isDateType(type):
 54 | 			typeString = "Date";
 55 | 			break;
 56 | 
 57 | 		case type.isLiteral():
 58 | 			{
 59 | 				const literalValue = type.getLiteralValue();
 60 | 				switch (true) {
 61 | 					case type.isStringLiteral():
 62 | 						typeString =
 63 | 							literalValue !== undefined ? `'${literalValue}'` : type.getText();
 64 | 						break;
 65 | 					case type.isBooleanLiteral():
 66 | 					case type.isNumberLiteral():
 67 | 						typeString =
 68 | 							literalValue !== undefined
 69 | 								? literalValue.toString()
 70 | 								: type.getText();
 71 | 						break;
 72 | 					default:
 73 | 						typeString = type.getText();
 74 | 				}
 75 | 			}
 76 | 			break;
 77 | 
 78 | 		default:
 79 | 			typeString = type.getText();
 80 | 	}
 81 | 
 82 | 	return { typeString, imports: new Set() };
 83 | }
 84 | 
 85 | function handleArrayType(type: Type, next: (type: Type) => FormattedType) {
 86 | 	const elementType = type.getArrayElementTypeOrThrow();
 87 | 	const elementResult = next(elementType);
 88 | 	const { imports } = elementResult;
 89 | 	const typeString = isPrimitive(elementType)
 90 | 		? `${elementResult.typeString}[]`
 91 | 		: `Array<\n${indent(elementResult?.typeString)}\n>`;
 92 | 	return { typeString, imports };
 93 | }
 94 | 
 95 | function handleTupleType(
 96 | 	type: Type,
 97 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
 98 | 	flags: FormatFlags[],
 99 | ) {
100 | 	const tupleResults = type
101 | 		.getTupleElements()
102 | 		.map((elementType) => next(elementType, flags));
103 | 	const imports = new Set(
104 | 		tupleResults.flatMap((r) => (r.imports ? Array.from(r.imports) : [])),
105 | 	);
106 | 	const typeString = `[\n${indent(
107 | 		tupleResults.map((r) => r.typeString).join(",\n"),
108 | 	)}\n]`;
109 | 	return { typeString, imports };
110 | }
111 | 
112 | function handlePromiseType(
113 | 	type: Type,
114 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
115 | 	flags: FormatFlags[],
116 | ) {
117 | 	const promiseType = type.getTypeArguments()[0];
118 | 	const promiseResult = next(promiseType, flags);
119 | 	const typeString = isPrimitive(promiseType)
120 | 		? `Promise<${promiseResult.typeString}>`
121 | 		: `Promise<\n${indent(promiseResult.typeString)}\n>`;
122 | 
123 | 	return { typeString, imports: promiseResult.imports };
124 | }
125 | 
126 | function getJSDocComment(node: Node): string | undefined {
127 | 	if (Node.isJSDocable(node)) {
128 | 		const jsDocs = node.getJsDocs();
129 | 		const jsdoc = jsDocs.at(0);
130 | 		if (jsdoc) {
131 | 			return jsdoc.getDescription().trim();
132 | 		}
133 | 	}
134 | 	return undefined;
135 | }
136 | 
137 | export function footprintOfType({
138 | 	type,
139 | 	node,
140 | 	overrides = {},
141 | 	flags = [],
142 | 	depth = 0,
143 | 	typeChecker,
144 | }: FootprintParams): FormattedType {
145 | 	// Check if we've already processed this type
146 | 	if (processedTypes.has(type)) {
147 | 		// biome-ignore lint/style/noNonNullAssertion: <explanation>
148 | 		return processedTypes.get(type)!;
149 | 	}
150 | 
151 | 	// if object, check depth first:
152 | 	// if depth > MAX_DEPTH, try to import the type instead
153 | 
154 | 	let result: FormattedType = { typeString: "", imports: new Set() };
155 | 
156 | 	// if (type.isObject()) {
157 | 	//   new Traverse(type, {}).forEach((ctx, x) => {
158 | 	//     if (ctx.level > MAX_DEPTH) {
159 | 	//       result = getTypeImport(type, file);
160 | 	//       ctx.stop();
161 | 	//     }
162 | 	//   });
163 | 	// }
164 | 
165 | 	if (depth > DEPTH_LIMIT && !flags.includes("traverse")) {
166 | 		throw new Error(`Max depth exceeded for type: ${type.getText()}`);
167 | 	}
168 | 
169 | 	if (depth > MAX_DEPTH && flags.includes("traverse")) {
170 | 		return { typeString: "unknown", imports: new Set<string>() };
171 | 	}
172 | 
173 | 	//   // console.log("max depth", type.getText());
174 | 	//   // If we've exceeded the maximum depth, try to import the type instead
175 | 	//   const importInfo = getTypeImport(type, file);
176 | 
177 | 	//   if (importInfo) {
178 | 	//     // console.log(importInfo);
179 | 	//     return importInfo;
180 | 	//   }
181 | 	//   // If we can't import, fall back to 'any'
182 | 	//   console.warn(
183 | 	//     `Max depth exceeded for type: ${type.getText()}. Using 'any' instead.`
184 | 	//   );
185 | 	//   return { typeString: "any", imports: new Set() };
186 | 	// }
187 | 
188 | 	const jsdoc = getJSDocComment(node);
189 | 	if (jsdoc) {
190 | 		console.error(jsdoc);
191 | 		result.jsdoc = jsdoc;
192 | 	}
193 | 
194 | 	const symbol = type.isEnum() ? type.getSymbol() : type.getAliasSymbol();
195 | 	if (symbol && overrides[symbol.getName()]) {
196 | 		console.log("symbol override", symbol.getName());
197 | 		return { typeString: overrides[symbol.getName()], imports: new Set() };
198 | 	}
199 | 
200 | 	const next = (nextType: Type, nextFlags: FormatFlags[] = []): FormattedType =>
201 | 		footprintOfType({
202 | 			type: nextType,
203 | 			node,
204 | 			overrides,
205 | 			flags: [...flags, ...nextFlags],
206 | 			depth: depth + 1,
207 | 			typeChecker,
208 | 		});
209 | 
210 | 	const type_alias = node.getSourceFile().getTypeAlias(type.getText());
211 | 
212 | 	if (type_alias) {
213 | 		return next(type_alias.getType(), [...flags, "traverse"]);
214 | 	}
215 | 	if (
216 | 		!(type_alias ?? type).getText().includes("Prisma.") ||
217 | 		!(type_alias ?? type).getText().includes("prisma.")
218 | 	) {
219 | 		const imported_type = getTypeImport(type, node.getSourceFile());
220 | 		if (imported_type) {
221 | 			return imported_type;
222 | 		}
223 | 	}
224 | 
225 | 	// print type
226 | 
227 | 	if (isPrimitive(type)) {
228 | 		// console.log("primitive", type.getText());
229 | 		result = handlePrimitiveType(type);
230 | 	} else if (type.isArray()) {
231 | 		result = handleArrayType(type, next);
232 | 	} else if (type.isTuple()) {
233 | 		result = handleTupleType(type, next, flags);
234 | 	} else if (isPromise(type)) {
235 | 		result = handlePromiseType(type, next, flags);
236 | 	} else if (isSimpleSignature(type)) {
237 | 		// console.log("signature", type.getText());
238 | 		result = formatSignatures(type.getCallSignatures(), "type", next);
239 | 	} else if (type.isObject()) {
240 | 		try {
241 | 			result = formatObject(type, node, next);
242 | 		} catch (e) {
243 | 			result = getTypeImport(type, node.getSourceFile());
244 | 		}
245 | 	} else if (type.isUnion()) {
246 | 		result = formatUnion(type, flags, next);
247 | 	} else if (type.isIntersection()) {
248 | 		try {
249 | 			result = formatIntersection(type, node, flags, next);
250 | 		} catch (e) {
251 | 			console.error((e as Error).message);
252 | 			result = getTypeImport(type, node.getSourceFile());
253 | 		}
254 | 	} else {
255 | 		console.log("type import", type.getText());
256 | 		const importInfo = getTypeImport(type, node.getSourceFile());
257 | 
258 | 		if (importInfo) {
259 | 			result = importInfo;
260 | 		} else {
261 | 			console.warn("Unhandled type:", type.getText());
262 | 			result.typeString = "any"; // or 'unknown', depending on your preference
263 | 		}
264 | 	}
265 | 
266 | 	// Cache the result before returning
267 | 	processedTypes.set(type, result);
268 | 
269 | 	return result;
270 | }
271 | 
272 | function formatImportAndType(text: string): FormattedType {
273 | 	const result: FormattedType & { imports: Set<string> } = {
274 | 		imports: new Set<string>(),
275 | 	};
276 | 
277 | 	// Regular expression pattern for imports
278 | 	const importPattern = /import\(([^)]+)\)\s*\.\s*(\*|\w+)(?:\s*\.\s*(\w+))?/g;
279 | 
280 | 	let match: string;
281 | 	let typeString = text;
282 | 	const importPaths = new Map<string, Set<string>>();
283 | 
284 | 	while ((match = importPattern.exec(text)) !== null) {
285 | 		const [fullMatch, importPath, namespace, specificType] = match;
286 | 		const cleanImportPath = importPath.replace(/["']/g, "");
287 | 
288 | 		let import_path = importPaths.get(cleanImportPath);
289 | 		if (!import_path) {
290 | 			import_path = importPaths
291 | 				.set(cleanImportPath, new Set<string>())
292 | 				.get(cleanImportPath) as Set<string>;
293 | 		}
294 | 
295 | 		if (namespace) {
296 | 			if (namespace === "*") {
297 | 				import_path.add("*");
298 | 			} else {
299 | 				import_path.add(namespace);
300 | 			}
301 | 		}
302 | 
303 | 		// Only replace the import part, preserving the namespace if it's a namespace import
304 | 		if (specificType) {
305 | 			typeString = typeString.replace(
306 | 				fullMatch,
307 | 				`${namespace}.${specificType}`,
308 | 			);
309 | 		} else {
310 | 			typeString = typeString.replace(fullMatch, namespace);
311 | 		}
312 | 	}
313 | 
314 | 	// Generate import statements
315 | 	for (const [path, imports] of importPaths) {
316 | 		// check the file extension
317 | 		const extension = path.split(".").pop();
318 | 		if (imports.has("*")) {
319 | 			result.imports.add(
320 | 				`import type * from "${path}${
321 | 					extension && extension?.length < 4 ? extension?.length : ".js"
322 | 				}"`,
323 | 			);
324 | 		} else {
325 | 			const importList = Array.from(imports).join(", ");
326 | 			result.imports.add(
327 | 				`import type { ${importList} } from "${path}${
328 | 					extension && extension?.length < 4 ? extension?.length : ".js"
329 | 				}"`,
330 | 			);
331 | 		}
332 | 	}
333 | 
334 | 	result.typeString = typeString.trim();
335 | 
336 | 	return result;
337 | }
338 | 
339 | function getTypeImport(type: Type, sourceFile: SourceFile): FormattedType {
340 | 	const typeAliases = sourceFile.getTypeAliases();
341 | 	const imports = new Set<string>();
342 | 
343 | 	function areTypesEquivalent(type1: Type, type2: Type): boolean {
344 | 		return type1.getText() === type2.getText();
345 | 	}
346 | 
347 | 	function standardizeImport(importDecl: ImportDeclaration): string {
348 | 		const namedImports = importDecl
349 | 			.getNamedImports()
350 | 			.map((named) => named.getName());
351 | 		const moduleSpecifier = importDecl.getModuleSpecifierValue();
352 | 
353 | 		const importedSourceFile = importDecl.getModuleSpecifierSourceFile();
354 | 		if (importedSourceFile) {
355 | 			if (
356 | 				importedSourceFile.isFromExternalLibrary() ||
357 | 				importedSourceFile.isInNodeModules()
358 | 			) {
359 | 				// For external libraries or node_modules, use the module specifier as is
360 | 				return `import type { ${namedImports.join(", ")} } from "${moduleSpecifier}";`;
361 | 			}
362 | 			// For local imports, use relative path
363 | 			const relativePath =
364 | 				sourceFile.getRelativePathAsModuleSpecifierTo(importedSourceFile);
365 | 			return `import type { ${namedImports.join(", ")} } from "${relativePath}";`;
366 | 		}
367 | 
368 | 		// Fallback to original module specifier if source file not found
369 | 		return `import type { ${namedImports.join(", ")} } from "${moduleSpecifier}";`;
370 | 	}
371 | 
372 | 	function getExternalImports(node: Node): Set<string> {
373 | 		const externalImports = new Set<string>();
374 | 		const project = node.getProject();
375 | 
376 | 		node.forEachDescendant((descendant) => {
377 | 			if (Node.isIdentifier(descendant)) {
378 | 				const symbol = descendant.getSymbol();
379 | 				if (symbol) {
380 | 					const declarations = symbol.getDeclarations();
381 | 					for (const declaration of declarations) {
382 | 						const importDecl = declaration.getFirstAncestorByKind(
383 | 							SyntaxKind.ImportDeclaration,
384 | 						);
385 | 						if (importDecl) {
386 | 							externalImports.add(standardizeImport(importDecl));
387 | 						}
388 | 					}
389 | 				}
390 | 			}
391 | 		});
392 | 
393 | 		return externalImports;
394 | 	}
395 | 
396 | 	function getFormattedTypeFromAlias(
397 | 		alias: TypeAliasDeclaration,
398 | 	): FormattedType | null {
399 | 		const aliasType = alias.getType();
400 | 		if (areTypesEquivalent(type, aliasType)) {
401 | 			const aliasName = alias.getName();
402 | 			const importDeclaration = alias.getFirstAncestorByKind(
403 | 				SyntaxKind.ImportDeclaration,
404 | 			);
405 | 
406 | 			if (importDeclaration) {
407 | 				imports.add(standardizeImport(importDeclaration));
408 | 			} else if (!alias.isExported()) {
409 | 				// If the type is not exported, copy its definition and get external imports
410 | 				const aliasDefinition = alias.getFullText();
411 | 				imports.add(aliasDefinition);
412 | 
413 | 				// Add standardized external imports
414 | 				const externalImports = getExternalImports(alias);
415 | 				externalImports.forEach((imp) => imports.add(imp));
416 | 			}
417 | 
418 | 			return {
419 | 				typeString: aliasName,
420 | 				imports,
421 | 			};
422 | 		}
423 | 		return null;
424 | 	}
425 | 
426 | 	// Try to find a matching type alias
427 | 	for (const alias of typeAliases) {
428 | 		const formattedType = getFormattedTypeFromAlias(alias);
429 | 		if (formattedType) {
430 | 			return formattedType;
431 | 		}
432 | 	}
433 | 
434 | 	if (type.getText().includes("import")) {
435 | 		return formatImportAndType(type.getText());
436 | 	}
437 | 
438 | 	// If no matching alias is found, fall back to the full type text
439 | 	return {
440 | 		typeString: type.getText(),
441 | 		imports,
442 | 	};
443 | }
444 | 
445 | function isDateType(type: Type): boolean {
446 | 	return type.isObject() && type.getSymbol()?.getName() === "Date";
447 | }
448 | 
449 | function isPrimitive(type: Type): boolean {
450 | 	if (PRIMITIVE_TYPES.has(type.getText())) return true;
451 | 	return !!(
452 | 		type.isLiteral() ||
453 | 		type.isUndefined() ||
454 | 		type.isNull() ||
455 | 		type.isUnknown() ||
456 | 		type.isAny() ||
457 | 		type.isVoid() ||
458 | 		type.isNever() ||
459 | 		type.getFlags() & TypeFlags.BigIntLiteral ||
460 | 		isDateType(type)
461 | 	);
462 | }
463 | 
464 | function isPromise(type: Type): boolean {
465 | 	const symbol = type.getSymbol();
466 | 	return (
467 | 		type.isObject() &&
468 | 		symbol?.getName() === "Promise" &&
469 | 		type.getTypeArguments().length === 1
470 | 	);
471 | }
472 | 
473 | function isSimpleSignature(type: Type): boolean {
474 | 	if (!type.isObject()) return false;
475 | 	const sigs = type.getCallSignatures();
476 | 	return (
477 | 		sigs.length === 1 &&
478 | 		type.getProperties().length === 0 &&
479 | 		type.getTypeArguments().length === 0 &&
480 | 		!type.getNumberIndexType() &&
481 | 		!type.getStringIndexType()
482 | 	);
483 | }
484 | 
485 | function indent(text: string, level: number = 1): string {
486 | 	return text.replace(/^/gm, " ".repeat(level * 2));
487 | }
488 | 
489 | function formatSignatures(
490 | 	sigs: Signature[],
491 | 	variant: "type" | "declaration",
492 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
493 | ): FormattedType {
494 | 	const results = sigs.map((sig) => formatSignature(sig, variant, next));
495 | 	const imports = new Set(results.flatMap((r) => Array.from(r.imports)));
496 | 	const typeString = results.map((r) => r.typeString).join("\n");
497 | 	return { typeString, imports };
498 | }
499 | 
500 | function formatObject(
501 | 	type: Type,
502 | 	node: Node,
503 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
504 | ): FormattedType {
505 | 	const typeArguments = type.getTypeArguments();
506 | 	if (typeArguments.length > 0) {
507 | 		return formatGenericObject(type, typeArguments, next);
508 | 	}
509 | 
510 | 	const properties = type.getProperties();
511 | 	const propertyResults = properties.map((prop) => {
512 | 		const propType = prop.getTypeAtLocation(node);
513 | 		const propResult = next(propType, []);
514 | 		return {
515 | 			name: prop.getName(),
516 | 			optional: prop.hasFlags(SymbolFlags.Optional),
517 | 			...propResult,
518 | 		};
519 | 	});
520 | 
521 | 	const imports = new Set(
522 | 		propertyResults.flatMap((p) => (p.imports ? Array.from(p.imports) : [])),
523 | 	);
524 | 	const typeString = `{${propertyResults
525 | 		.map((p) => `  ${p.name}${p.optional ? "?" : ""}: ${p.typeString};`)
526 | 		.join("\n")}}`;
527 | 
528 | 	return { typeString, imports };
529 | }
530 | 
531 | function formatGenericObject(
532 | 	type: Type,
533 | 	typeArguments: Type[],
534 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
535 | ): FormattedType {
536 | 	const baseTypeName = type.getSymbol()?.getName() || "unknown";
537 | 	const typeArgResults = typeArguments.map((arg) => next(arg, []));
538 | 	const imports = new Set(typeArgResults.flatMap((r) => Array.from(r.imports)));
539 | 	const typeString = `${baseTypeName}<${typeArgResults
540 | 		.map((r) => r.typeString)
541 | 		.join(", ")}>`;
542 | 	return { typeString, imports };
543 | }
544 | 
545 | function formatUnion(
546 | 	type: Type,
547 | 	flags: FormatFlags[],
548 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
549 | ): FormattedType {
550 | 	const results = type
551 | 		.getUnionTypes()
552 | 		.filter(
553 | 			(t) =>
554 | 				!flags.includes("remove-undefined-from-intersections") ||
555 | 				!t.isUndefined(),
556 | 		)
557 | 		.map((t) => next(t, flags));
558 | 
559 | 	const imports = new Set(results.flatMap((r) => Array.from(r.imports)));
560 | 	const typeString = results.map((r) => r.typeString).join(" | ");
561 | 	return { typeString, imports };
562 | }
563 | 
564 | function formatIntersection(
565 | 	type: Type,
566 | 	node: Node,
567 | 	flags: FormatFlags[],
568 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
569 | ): FormattedType {
570 | 	const intersectionTypes = type.getIntersectionTypes();
571 | 	const results = intersectionTypes.map((t) => next(t, flags));
572 | 
573 | 	const imports = new Set(results.flatMap((r) => Array.from(r.imports)));
574 | 
575 | 	// Separate object types and non-object types
576 | 	const objectTypes: string[] = [];
577 | 	const nonObjectTypes: string[] = [];
578 | 
579 | 	results.forEach((r) => {
580 | 		if (r.typeString.trim().startsWith("{")) {
581 | 			// This is an object type, extract its properties
582 | 			objectTypes.push(r.typeString.slice(1, -1).trim());
583 | 		} else {
584 | 			// This is not an object type, keep it as is
585 | 			nonObjectTypes.push(r.typeString);
586 | 		}
587 | 	});
588 | 
589 | 	// Combine object types
590 | 	const combinedObjectType =
591 | 		objectTypes.length > 0 ? `{\n${objectTypes.join("\n")}\n}` : "";
592 | 
593 | 	// Combine all types
594 | 	const allTypes = [...nonObjectTypes];
595 | 	if (combinedObjectType) {
596 | 		allTypes.push(combinedObjectType);
597 | 	}
598 | 
599 | 	const typeString =
600 | 		allTypes.length > 1
601 | 			? `(\n${indent(allTypes.join(" &\n"))}\n)`
602 | 			: allTypes[0];
603 | 
604 | 	return { typeString, imports };
605 | }
606 | 
607 | function formatProperty(
608 | 	prop: TsMorphSymbol,
609 | 	node: Node,
610 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
611 | ): FormattedType {
612 | 	const type = prop.getTypeAtLocation(node);
613 | 	const sigs = type.getCallSignatures();
614 | 	const firstSig = sigs[0];
615 | 
616 | 	if (
617 | 		isSimpleSignature(type) &&
618 | 		!prop.hasFlags(SymbolFlags.Optional) &&
619 | 		firstSig
620 | 	) {
621 | 		const result = formatSignature(
622 | 			firstSig,
623 | 			"declaration",
624 | 			next,
625 | 			prop.getName(),
626 | 		);
627 | 		return { ...result, typeString: result.typeString + ";" };
628 | 	}
629 | 
630 | 	const isOptional = prop.hasFlags(SymbolFlags.Optional);
631 | 	const result = next(
632 | 		type,
633 | 		[isOptional ? "remove-undefined-from-intersections" : false].filter(
634 | 			(flag): flag is FormatFlags => flag !== false,
635 | 		),
636 | 	);
637 | 
638 | 	return {
639 | 		...result,
640 | 		typeString: `${prop.getName()}${isOptional ? "?" : ""}: ${
641 | 			result.typeString
642 | 		};`,
643 | 	};
644 | }
645 | 
646 | function formatProperties(
647 | 	props: TsMorphSymbol[],
648 | 	node: Node,
649 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
650 | ): FormattedType {
651 | 	const results = props
652 | 		.filter((prop) => {
653 | 			if (prop.getValueDeclaration()?.getType().getCallSignatures().length)
654 | 				return false;
655 | 			const declaration = prop.getValueDeclaration();
656 | 			if (Node.isIndexSignatureDeclaration(declaration)) return false;
657 | 			if (prop.getDeclarations().some(Node.isMethodDeclaration)) return false;
658 | 			const name = prop.getName();
659 | 			if (name.startsWith("__@")) return false;
660 | 			return true;
661 | 		})
662 | 		.map((prop) => formatProperty(prop, node, next));
663 | 
664 | 	const imports = new Set(results.flatMap((r) => Array.from(r.imports)));
665 | 	const typeString = results.map((r) => r.typeString).join("\n");
666 | 	return { typeString, imports };
667 | }
668 | 
669 | function formatSignature(
670 | 	sig: Signature,
671 | 	variant: "type" | "declaration",
672 | 	next: (type: Type, flags: FormatFlags[]) => FormattedType,
673 | 	methodName?: string,
674 | 	flags: FormatFlags[] = [],
675 | ): FormattedType {
676 | 	const name = sig.getDeclaration().getSymbol()?.getName();
677 | 	const nameToUse =
678 | 		methodName ?? (["__type", "__call"].includes(name ?? "") ? "" : name);
679 | 
680 | 	const paramResults = sig.getParameters().map((param) => {
681 | 		const paramType = param
682 | 			.getDeclarations()
683 | 			.map((decl) => next(decl.getType(), flags))
684 | 			.reduce(
685 | 				(acc, curr) => ({
686 | 					typeString: acc.typeString + curr.typeString,
687 | 					imports: new Set([...acc.imports, ...curr.imports]),
688 | 				}),
689 | 				{ typeString: "", imports: new Set<string>() },
690 | 			);
691 | 
692 | 		return {
693 | 			name: param.getName(),
694 | 			optional: param.hasFlags(SymbolFlags.Optional),
695 | 			...paramType,
696 | 		};
697 | 	});
698 | 
699 | 	const returnTypeResult = next(sig.getReturnType(), flags);
700 | 
701 | 	const imports = new Set([
702 | 		...paramResults.flatMap((p) => Array.from(p.imports)),
703 | 		...Array.from(returnTypeResult.imports),
704 | 	]);
705 | 
706 | 	const paramsString = paramResults
707 | 		.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.typeString}`)
708 | 		.join(", ");
709 | 
710 | 	const typeString = `${
711 | 		variant === "declaration" ? nameToUse : ""
712 | 	}(${paramsString})${variant === "declaration" ? ": " : " => "}${
713 | 		returnTypeResult.typeString
714 | 	}`;
715 | 
716 | 	return { typeString, imports };
717 | }
718 | 


--------------------------------------------------------------------------------
/src/utils/tsoa.ts:
--------------------------------------------------------------------------------
  1 | import fs from "node:fs/promises";
  2 | import { existsSync } from "node:fs";
  3 | import type {
  4 | 	EndpointDefinition,
  5 | 	Endpoints,
  6 | 	MethodMap,
  7 | } from "../types/core.js";
  8 | import {
  9 | 	generateRoutes,
 10 | 	generateSpec,
 11 | 	type ExtendedRoutesConfig,
 12 | 	type ExtendedSpecConfig,
 13 | } from "tsoa";
 14 | import path from "node:path";
 15 | import { brackets, newline } from "./writers.js";
 16 | 
 17 | export async function generate_tsoa_shema(
 18 | 	endpoints: Endpoints,
 19 | 	staticFolder: string,
 20 | ) {
 21 | 	for (const [api_path, method_map] of endpoints.entries()) {
 22 | 		const controller = generate_tsoa_controller(api_path, method_map);
 23 | 		if (controller) {
 24 | 			await write_route_controller(api_path, controller, staticFolder);
 25 | 		}
 26 | 	}
 27 | 	await write_spec(staticFolder);
 28 | }
 29 | 
 30 | function generate_tsoa_controller(path: string, method_map: MethodMap) {
 31 | 	const imports = new Set<string>([
 32 | 		'import { Body, Controller, Response,Route, SuccessResponse } from "tsoa";',
 33 | 	]);
 34 | 
 35 | 	const controller_name = path
 36 | 		.replace(/:(\w+)/g, "$1")
 37 | 		.replace(/\//g, "")
 38 | 		.replace(/-/g, "");
 39 | 
 40 | 	const endpoint = generate_route_controller(path, method_map);
 41 | 	// biome-ignore lint/complexity/noForEach: <explanation>
 42 | 	endpoint.imports.forEach((imp) => imports.add(imp));
 43 | 
 44 | 	let output = `
 45 |         @Route("${path}")
 46 |         export class ${controller_name}Controller extends Controller`;
 47 | 	output += newline(brackets(endpoint.output));
 48 | 	output = [Array.from(imports).join("\n"), output].join("\n");
 49 | 	return output;
 50 | }
 51 | 
 52 | function generate_route_controller(
 53 | 	api_path: string,
 54 | 	method_map: MethodMap,
 55 | ): {
 56 | 	imports: Set<string>;
 57 | 	output: string;
 58 | } {
 59 | 	const imports = new Set<string>();
 60 | 	let output = "";
 61 | 	for (const [method, endpoint] of method_map.entries()) {
 62 | 		const method_name = method.slice(0, 1) + method.slice(1).toLowerCase();
 63 | 		// capitalize
 64 | 		imports.add(
 65 | 			`import { ${method.slice(0, 1)}${method.slice(1).toLowerCase()} } from "tsoa";`,
 66 | 		);
 67 | 
 68 | 		output += `
 69 |         @${method_name}()`;
 70 | 		const responses = generate_endpoint_responses(endpoint);
 71 | 		output += responses.responses.join("\n");
 72 | 		for (const imp of responses.imports) {
 73 | 			imports.add(imp);
 74 | 		}
 75 | 		const args: string[] = [];
 76 | 
 77 | 		output += `public async ${method_name.toLowerCase()}(`;
 78 | 
 79 | 		if (endpoint.parameters.path) {
 80 | 			Object.entries(endpoint.parameters.path).map(([key, value]) =>
 81 | 				args.push(`@Path() ${key}: ${value}`),
 82 | 			);
 83 | 		}
 84 | 
 85 | 		if (endpoint.parameters.body) {
 86 | 			if (endpoint.parameters.body.imports) {
 87 | 				for (const imp of endpoint.parameters.body.imports) {
 88 | 					imports.add(imp);
 89 | 				}
 90 | 			}
 91 | 			args.push(`@Body() body: ${endpoint.parameters.body.typeString}`);
 92 | 		}
 93 | 		// else {
 94 | 		// 	output += `public async ${method_name.toLowerCase()}(): Promise<void> {
 95 | 		//         return;
 96 | 		//     }`;
 97 | 		// }
 98 | 
 99 | 		if (endpoint.parameters.query) {
100 | 			imports.add('import { Query } from "tsoa";');
101 | 			Object.entries(endpoint.parameters.query)
102 | 				.map(([key, value]) => {
103 | 					if (value.imports) {
104 | 						for (const imp of value.imports) {
105 | 							imports.add(imp);
106 | 						}
107 | 					}
108 | 					args.push(`@Query() ${key}: ${value.typeString}`);
109 | 				})
110 | 				.join(",");
111 | 		}
112 | 		output += `
113 |         ${args.join("\n,")}
114 |         ) {
115 |                 return ${endpoint.responses[200]?.at(0)?.typeString ? `({} as ${endpoint.responses[200]?.at(0)?.typeString})` : ""};
116 |             }`;
117 | 	}
118 | 
119 | 	return { imports, output };
120 | }
121 | 
122 | async function write_route_controller(
123 | 	api_path: string,
124 | 	output: string,
125 | 	staticFolder: string,
126 | ) {
127 | 	const output_path = path.join(
128 | 		staticFolder,
129 | 		"tsoa",
130 | 		"controllers",
131 | 		api_path.replace(/:(\w+)/g, "{$1}"),
132 | 	);
133 | 	// create dir
134 | 	if (!existsSync(output_path)) {
135 | 		await fs.mkdir(output_path, { recursive: true });
136 | 	}
137 | 	await fs.writeFile(path.join(output_path, "Controller.ts"), output);
138 | }
139 | 
140 | function generate_endpoint_responses(endpoint: EndpointDefinition): {
141 | 	responses: string[];
142 | 	imports: Set<string>;
143 | } {
144 | 	const imports = new Set<string>();
145 | 	const responses: string[] = [];
146 | 	for (const [status, res] of Object.entries(endpoint.responses)) {
147 | 		if (res) {
148 | 			const responses: string[] = [];
149 | 			for (const response of res) {
150 | 				response.imports?.forEach((imp, i) => imports.add(imp));
151 | 				if (response.typeString) {
152 | 					responses.push(response.typeString);
153 | 				}
154 | 			}
155 | 			const http_status = Number.parseInt(status);
156 | 			responses.push(`@Response<${responses.join(" | ")}>(${http_status})\n`);
157 | 		}
158 | 	}
159 | 	for (const [status, res] of Object.entries(endpoint.errors)) {
160 | 		if (res) {
161 | 			for (const response of res) {
162 | 				if (response.imports) {
163 | 					for (const imp of response.imports) {
164 | 						imports.add(imp);
165 | 					}
166 | 
167 | 					const http_status = Number.parseInt(status);
168 | 
169 | 					responses.push(`@Response<${response.typeString}>(${http_status})\n`);
170 | 				}
171 | 			}
172 | 		}
173 | 	}
174 | 	return { responses, imports };
175 | }
176 | 
177 | async function write_spec(staticFolder: string) {
178 | 	const tsoa_working_dir = path.join(staticFolder, "tsoa");
179 | 	const spec_output_path = path.join(staticFolder, "api", "schemas");
180 | 	if (!existsSync(tsoa_working_dir)) {
181 | 		await fs.mkdir(tsoa_working_dir, { recursive: true });
182 | 	}
183 | 	console.log(spec_output_path);
184 | 	await generateSpec(
185 | 		{
186 | 			basePath: "/api",
187 | 
188 | 			entryFile: `${path.join(tsoa_working_dir, "server.ts")}`,
189 | 			specVersion: 3,
190 | 			outputDirectory: spec_output_path,
191 | 			controllerPathGlobs: [
192 | 				path.join(tsoa_working_dir, "controllers/**/*Controller.ts"),
193 | 			],
194 | 			noImplicitAdditionalProperties: "silently-remove-extras",
195 | 		},
196 | 		undefined,
197 | 		[
198 | 			"**/node_modules/@types/**",
199 | 			"**/node_modules/typescript/**",
200 | 			"**/node_modules/@tsoa/**",
201 | 			"**/@tsoa/cli/node_modules/**",
202 | 		],
203 | 	)
204 | 		.then(async () => {
205 | 			await fs.rm(tsoa_working_dir, { recursive: true, force: true });
206 | 		})
207 | 		.catch((e) => {
208 | 			console.error("Error while generating OpenAPI Spec", e);
209 | 			throw e;
210 | 		});
211 | }
212 | 


--------------------------------------------------------------------------------
/src/utils/unroll-types.ts:
--------------------------------------------------------------------------------
  1 | import * as tsm from "ts-morph";
  2 | import { ImportNodeUtil } from "./import-utils.js";
  3 | import {
  4 | 	type Diagnostic,
  5 | 	emitFileDeclaration,
  6 | 	getDeclarationNode,
  7 | 	getNodeId,
  8 | 	isExportable,
  9 | 	hasOwnIdentifier,
 10 | 	isJsDocChild,
 11 | 	replaceTransientImports,
 12 | 	isDeclaration,
 13 | 	getExportableNode,
 14 | 	getDefinitionNodes,
 15 | 	isReferencedByAncestorDeclaration,
 16 | 	getStatement,
 17 | 	outputNodeText,
 18 | 	replaceTransientImport,
 19 | } from "./util.js";
 20 | 
 21 | /**
 22 |  *
 23 |  * @param inFiles A file list of entry files
 24 |  * @param tsConfigFilePath An optional config path for tsconfig.json
 25 |  * @param compilerOptions Optional compiler options for the TypeScript compiler
 26 |  * @param defaultInternal Whether to treat all exports as internal by default
 27 |  * @returns
 28 |  */
 29 | export const unrollTypes = async ({
 30 | 	project,
 31 | 	file,
 32 | 	wrapInGlobal = [],
 33 | 	globalExternals = [],
 34 | 	defaultInternal = false,
 35 | 	prefix = "",
 36 | }: {
 37 | 	project: tsm.Project;
 38 | 	file: string;
 39 | 	tsConfigFilePath?: string;
 40 | 	wrapInGlobal?: string[];
 41 | 	globalExternals?: string[];
 42 | 	defaultInternal?: boolean;
 43 | 	prefix?: string;
 44 | }) => {
 45 | 	let result = {
 46 | 		content: "",
 47 | 		global: "",
 48 | 		prepend: "",
 49 | 		diagnostics: {
 50 | 			nodeModules: new Set<string>(),
 51 | 			external: new Set<string>(),
 52 | 			notFound: new Set<string>(),
 53 | 			importFileNotFound: new Set<string>(),
 54 | 			externalDeclarations: new Set<string>(),
 55 | 			nameClash: new Set<string>(),
 56 | 			failedToPrint: new Set<string>(),
 57 | 		} as Diagnostic,
 58 | 	};
 59 | 
 60 | 	/** The source TS files */
 61 | 	const inProject = project;
 62 | 
 63 | 	/** Matching declaration files will be outputted and found here */
 64 | 	const outProject = new tsm.Project({
 65 | 		skipAddingFilesFromTsConfig: true,
 66 | 		compilerOptions: {
 67 | 			...inProject.getCompilerOptions(),
 68 | 			declaration: true,
 69 | 			emitDeclarationOnly: true,
 70 | 			declarationDir: "/outdir",
 71 | 		},
 72 | 		useInMemoryFileSystem: true,
 73 | 	});
 74 | 
 75 | 	const _collectedNodeDefinitions: tsm.Node[] = [];
 76 | 	const _collectedNodeDefinitionsListMap = new Map<string, tsm.Node[]>();
 77 | 	const _printedNodeDeclarations = new Set<tsm.Node>();
 78 | 
 79 | 	/**
 80 | 	 * Any import statements that are not in the project will be added to this list
 81 | 	 */
 82 | 	const nodeModuleImports = new ImportNodeUtil();
 83 | 
 84 | 	/**
 85 | 	 * Any import statements that in the project for d.ts files will be added to this list
 86 | 	 */
 87 | 	const nodeModuleDeclarationImports = new ImportNodeUtil();
 88 | 
 89 | 	// note: processed, not necessarily collected
 90 | 	const _alreadyTriedToCollectNode = new Set<tsm.Node>();
 91 | 
 92 | 	const _transients = new Set<{
 93 | 		node: tsm.ImportTypeNode;
 94 | 		sourceFile: tsm.SourceFile;
 95 | 		declarationFile: tsm.SourceFile;
 96 | 	}>();
 97 | 
 98 | 	/**
 99 | 	 * Recursively "collects" all definitions that are local to the project based off identifiers found in the source code (node).
100 | 	 *
101 | 	 * Goes through the source file and:
102 | 	 * 1. Iterates all node definitions of identifiers
103 | 	 * 2. If a definition node is external or in node modules simply add it to the diagnostics and skip it
104 | 	 * 3. If a definition node is in a declaration file, add it to nodeModuleDeclarationImports and diagnostics and skip it
105 | 	 * 4. If a definition node has already been processed, skip it
106 | 	 * 3. If a definition node is in the project, recursively call collect on it
107 | 	 *
108 | 	 * After the identifier definitions have been processed:
109 | 	 * 1. Generate all declaration files for each root node or fail
110 | 	 * 2. Get transient nodes from the declaration files and collect those as well
111 | 	 *
112 | 	 * @param parentNode tsm.Node
113 | 	 */
114 | 	function _traverse(parentNode: tsm.Node) {
115 | 		const sourceFile = parentNode.getSourceFile();
116 | 
117 | 		parentNode.getDescendantsOfKind(tsm.SyntaxKind.Identifier).forEach((id) => {
118 | 			if (isJsDocChild(id)) {
119 | 				return;
120 | 			}
121 | 
122 | 			let definitionNodes = getDefinitionNodes(id, inProject, true);
123 | 
124 | 			for (const defNode of definitionNodes) {
125 | 				// minor optimization to reduce work in this loop
126 | 				if (_alreadyTriedToCollectNode.has(defNode)) {
127 | 					continue;
128 | 				}
129 | 				_alreadyTriedToCollectNode.add(defNode);
130 | 
131 | 				if (defNode.getSourceFile().isFromExternalLibrary()) {
132 | 					result.diagnostics.external.add(id.getText());
133 | 					continue;
134 | 				}
135 | 				if (defNode.getSourceFile().isInNodeModules()) {
136 | 					// add node name to import list since it is external
137 | 					nodeModuleImports.registerImports(id, sourceFile);
138 | 					result.diagnostics.nodeModules.add(id.getText());
139 | 					continue;
140 | 				}
141 | 				if (defNode.getSourceFile().isDeclarationFile()) {
142 | 					nodeModuleDeclarationImports.registerImports(id, sourceFile);
143 | 					result.diagnostics.externalDeclarations.add(id.getText());
144 | 					continue;
145 | 				}
146 | 				_collect(defNode);
147 | 				_traverse(defNode);
148 | 			}
149 | 
150 | 			if (definitionNodes.length === 0) {
151 | 				result.diagnostics.notFound.add(id.getText());
152 | 			}
153 | 		});
154 | 
155 | 		// we emit the declaration after collecting exportable nodes
156 | 		// because we need to set them all to exported first!
157 | 		const declarationFile = emitFileDeclaration(
158 | 			inProject,
159 | 			parentNode.getSourceFile(),
160 | 			outProject,
161 | 		);
162 | 
163 | 		if (declarationFile === undefined) {
164 | 			console.error(parentNode.getSourceFile().getFilePath());
165 | 			throw new Error("Could not emit file declaration");
166 | 		}
167 | 
168 | 		for (const transient of declarationFile
169 | 			.getDescendantsOfKind(tsm.SyntaxKind.ImportType)
170 | 			.map((node) => ({
171 | 				node,
172 | 				sourceFile,
173 | 				declarationFile,
174 | 			}))) {
175 | 			_transients.add(transient);
176 | 		}
177 | 
178 | 		// const transient = replaceTransientImports(
179 | 		//     declarationFile,
180 | 		//     parentNode.getSourceFile(),
181 | 		//     inProject,
182 | 		//     result.diagnostics
183 | 		// );
184 | 
185 | 		// for (const node of transient) {
186 | 		//     _transients.add(node);
187 | 		//     _collect(node);
188 | 		//     _traverse(node);
189 | 		// }
190 | 	}
191 | 
192 | 	/**
193 | 	 * NOTE: This is a recursive function
194 | 	 *
195 | 	 * For any given node definition:
196 | 	 * 1. Retrieve its matching declaration and output it.
197 | 	 * 2. For each descendent of the declaration node, if it has an id and has been collected, output it.
198 | 	 * 3. If it does not have a declaration and is a declaration itself, output it.
199 | 	 */
200 | 	function printNode(_node: tsm.Node, srcDecl?: tsm.Node) {
201 | 		const outputNode = getStatement(_node);
202 | 
203 | 		if (_printedNodeDeclarations.has(outputNode)) {
204 | 			return;
205 | 		}
206 | 		_printedNodeDeclarations.add(outputNode);
207 | 
208 | 		const declNode = getDeclarationNode(outputNode, inProject, outProject);
209 | 
210 | 		if (declNode) {
211 | 			outputNodeText(declNode, outputNode.getSourceFile(), result, {
212 | 				wrapInGlobal,
213 | 				defaultInternal,
214 | 			});
215 | 
216 | 			declNode.forEachDescendant((desc) => {
217 | 				const nodeId = getNodeId(desc);
218 | 				if (nodeId) {
219 | 					// same id doesn't mean we're in the same tree, though we're assuming so
220 | 					const collectedNodeList = _collectedNodeDefinitionsListMap.get(
221 | 						nodeId.getText(),
222 | 					);
223 | 					if (collectedNodeList === undefined) {
224 | 						// we don't have any node definitions for this id
225 | 						// see if any external imports map to the symbol name
226 | 						if (hasOwnIdentifier(desc)) {
227 | 							if (
228 | 								!nodeModuleImports.prepareOutput(desc) &&
229 | 								!nodeModuleDeclarationImports.prepareOutput(desc)
230 | 							) {
231 | 								result.diagnostics.failedToPrint.add(nodeId.getText());
232 | 							}
233 | 						}
234 | 					} else if (collectedNodeList.length > 1) {
235 | 						// we support exporting interface and class with same name as TS does
236 | 						if (
237 | 							collectedNodeList.length === 2 &&
238 | 							collectedNodeList.some((node) =>
239 | 								tsm.Node.isClassDeclaration(node),
240 | 							) &&
241 | 							collectedNodeList.some((node) =>
242 | 								tsm.Node.isInterfaceDeclaration(node),
243 | 							)
244 | 						) {
245 | 							printNode(collectedNodeList[0], declNode);
246 | 							printNode(collectedNodeList[1], declNode);
247 | 						} else {
248 | 							result.diagnostics.nameClash.add(nodeId.getText());
249 | 						}
250 | 					} else if (collectedNodeList.length === 1) {
251 | 						printNode(collectedNodeList[0], declNode);
252 | 					}
253 | 				}
254 | 			});
255 | 		} else {
256 | 			// there will not be a declaration node if:
257 | 			// the node is not an exportable type
258 | 			// the node is not exported
259 | 			// however in our case we wish to include non-exported for convenience
260 | 			// so we will just print the node
261 | 			// we have to reach up and find out if parents have decl nodes
262 | 			// NOTE: now that we set nodes to export before hand, it will be odd to find nodes in this execution branch
263 | 			if (
264 | 				srcDecl &&
265 | 				// do we want just type reference?
266 | 				(isDeclaration(outputNode) || tsm.Node.isTypeReference(outputNode)) &&
267 | 				isReferencedByAncestorDeclaration(outputNode, srcDecl!)
268 | 			) {
269 | 				if (tsm.Node.isJSDocable(outputNode)) {
270 | 					outputNode.addJsDoc("@internal - inferred");
271 | 				}
272 | 				result.content +=
273 | 					`\n\n//${outputNode.getSourceFile().getFilePath()}\n` +
274 | 					outputNode.getFullText();
275 | 				_printedNodeDeclarations.add(outputNode);
276 | 			}
277 | 		}
278 | 	}
279 | 
280 | 	function _collect(node: tsm.Node) {
281 | 		if (hasOwnIdentifier(node) && isExportable(node)) {
282 | 			if (!_collectedNodeDefinitions.includes(node)) {
283 | 				const nodeId = getNodeId(node)!.getText();
284 | 				_collectedNodeDefinitions.push(node);
285 | 				if (_collectedNodeDefinitionsListMap.has(nodeId)) {
286 | 					_collectedNodeDefinitionsListMap.get(nodeId)!.push(node);
287 | 				} else {
288 | 					_collectedNodeDefinitionsListMap.set(nodeId, [node]);
289 | 				}
290 | 
291 | 				// set all nodes to exported so we can get declarations from TS
292 | 				getExportableNode(node).setIsExported(true);
293 | 			}
294 | 		}
295 | 	}
296 | 
297 | 	let sourceFile: tsm.SourceFile;
298 | 	// best effort for faulty configs
299 | 	if (inProject.getSourceFile(file) === undefined) {
300 | 		sourceFile = inProject.addSourceFileAtPath(file);
301 | 		console.warn(`File ${file} not found in tsconfig.json, adding...`);
302 | 	} else {
303 | 		sourceFile = inProject.getSourceFile(file);
304 | 	}
305 | 
306 | 	_traverse(sourceFile);
307 | 
308 | 	for (const t of _transients) {
309 | 		try {
310 | 			console.log(t.node.getFullText());
311 | 			_collect(replaceTransientImport(t, inProject, result.diagnostics));
312 | 		} catch (e) {
313 | 			console.error(e);
314 | 		}
315 | 	}
316 | 
317 | 	const rootNodes = [
318 | 		...(sourceFile.getExportedDeclarations().values() as Iterable<tsm.Node>),
319 | 	].flat();
320 | 
321 | 	// start at the root nodes of the source file and print only those types that are referenced from there
322 | 	for (const node of rootNodes) {
323 | 		printNode(node);
324 | 	}
325 | 
326 | 	result.content =
327 | 		nodeModuleImports.output +
328 | 		"\n" +
329 | 		nodeModuleDeclarationImports.output +
330 | 		"\n" +
331 | 		result.content;
332 | 
333 | 	return {
334 | 		content: `
335 |         ${prefix}
336 |         ${result.content}
337 |         declare global {
338 |             ${globalExternals.join("\n")}
339 |             ${result.global}
340 |         }
341 |         `,
342 | 		diagnostics: {
343 | 			external: [...result.diagnostics.external],
344 | 			importFileNotFound: [...result.diagnostics.importFileNotFound],
345 | 			nodeModules: [...result.diagnostics.nodeModules],
346 | 			notFound: [...result.diagnostics.notFound],
347 | 			...nodeModuleImports.diagnostics,
348 | 			nameClash: [...result.diagnostics.nameClash],
349 | 			failedToPrint: [...result.diagnostics.failedToPrint],
350 | 		},
351 | 	};
352 | };
353 | 


--------------------------------------------------------------------------------
/src/utils/util.ts:
--------------------------------------------------------------------------------
  1 | import _ from "lodash";
  2 | import { resolve, join } from "node:path";
  3 | import * as tsm from "ts-morph";
  4 | // import aliases from "../aliases";
  5 | 
  6 | export type Diagnostic = {
  7 | 	external: Set<string>;
  8 | 	importFileNotFound: Set<string>;
  9 | 	nodeModules: Set<string>;
 10 | 	externalDeclarations: Set<string>;
 11 | 	notFound: Set<string>;
 12 | 	nameClash: Set<string>;
 13 | 	failedToPrint: Set<string>;
 14 | };
 15 | 
 16 | export const fn = (filename: string) => resolve(process.cwd(), filename);
 17 | 
 18 | const _declarationFileCache = new Map<string, tsm.SourceFile>();
 19 | 
 20 | export const emitFileDeclaration = (
 21 | 	project: tsm.Project,
 22 | 	sourceFile: tsm.SourceFile,
 23 | 	outProject = new tsm.Project({
 24 | 		skipAddingFilesFromTsConfig: true,
 25 | 		compilerOptions: {
 26 | 			...project.getCompilerOptions(),
 27 | 			declaration: true,
 28 | 			emitDeclarationOnly: true,
 29 | 			declarationDir: "/outdir",
 30 | 			allowJs: true,
 31 | 			target: tsm.ScriptTarget.ESNext,
 32 | 			module: tsm.ModuleKind.ESNext,
 33 | 			jsx: tsm.ts.JsxEmit.React,
 34 | 		},
 35 | 		useInMemoryFileSystem: true,
 36 | 	}),
 37 | ) => {
 38 | 	if (_declarationFileCache.has(sourceFile.getFilePath())) {
 39 | 		return _declarationFileCache.get(sourceFile.getFilePath())!;
 40 | 	}
 41 | 
 42 | 	const memResult = project.emitToMemory({
 43 | 		emitOnlyDtsFiles: true,
 44 | 		targetSourceFile: sourceFile,
 45 | 	});
 46 | 
 47 | 	for (const memDefFiles of memResult.getFiles()) {
 48 | 		if (memDefFiles.filePath.endsWith(".d.ts")) {
 49 | 			const file = outProject.createSourceFile(
 50 | 				memDefFiles.filePath.replace(process.cwd().replace(/\\/g, "/"), ""),
 51 | 				memDefFiles.text,
 52 | 				{ overwrite: true },
 53 | 			);
 54 | 			_declarationFileCache.set(sourceFile.getFilePath(), file);
 55 | 			return file;
 56 | 		}
 57 | 	}
 58 | };
 59 | 
 60 | export const isDeclaration = (node: tsm.Node) => {
 61 | 	return (
 62 | 		tsm.Node.isClassDeclaration(node) ||
 63 | 		tsm.Node.isInterfaceDeclaration(node) ||
 64 | 		tsm.Node.isTypeAliasDeclaration(node) ||
 65 | 		tsm.Node.isVariableStatement(node) ||
 66 | 		tsm.Node.isVariableDeclaration(node) ||
 67 | 		tsm.Node.isFunctionDeclaration(node) ||
 68 | 		tsm.Node.isEnumDeclaration(node)
 69 | 	);
 70 | };
 71 | 
 72 | type NamedType =
 73 | 	| tsm.ClassDeclaration
 74 | 	| tsm.InterfaceDeclaration
 75 | 	| tsm.TypeAliasDeclaration
 76 | 	| tsm.VariableStatement
 77 | 	| tsm.VariableDeclaration
 78 | 	| tsm.FunctionDeclaration
 79 | 	| tsm.EnumDeclaration
 80 | 	| tsm.ImportTypeNode
 81 | 	| tsm.TypeReferenceNode
 82 | 	| tsm.HeritageClause
 83 | 	| tsm.ComputedPropertyName
 84 | 	| tsm.TypeQueryNode;
 85 | 
 86 | export function hasOwnIdentifier(node: tsm.Node): node is NamedType {
 87 | 	return (
 88 | 		tsm.Node.isClassDeclaration(node) ||
 89 | 		tsm.Node.isInterfaceDeclaration(node) ||
 90 | 		tsm.Node.isTypeAliasDeclaration(node) ||
 91 | 		tsm.Node.isVariableStatement(node) ||
 92 | 		tsm.Node.isVariableDeclaration(node) ||
 93 | 		tsm.Node.isFunctionDeclaration(node) ||
 94 | 		tsm.Node.isEnumDeclaration(node) ||
 95 | 		tsm.Node.isImportTypeNode(node) ||
 96 | 		tsm.Node.isTypeReference(node) ||
 97 | 		tsm.Node.isHeritageClause(node) ||
 98 | 		tsm.Node.isComputedPropertyName(node) ||
 99 | 		tsm.Node.isTypeQuery(node)
100 | 	);
101 | }
102 | 
103 | function hasJsDocTag<T extends tsm.Node>(node: T, needle: string) {
104 | 	if (tsm.Node.isJSDocable(node)) {
105 | 		for (const _n of node.getJsDocs()) {
106 | 			if (_n.getInnerText().includes(needle)) {
107 | 				return true;
108 | 			}
109 | 		}
110 | 	}
111 | 	return false;
112 | }
113 | 
114 | export const getExportableNode = (_node: tsm.Node) => {
115 | 	const node = tsm.Node.isVariableDeclaration(_node)
116 | 		? _node.getFirstAncestorByKind(tsm.SyntaxKind.VariableStatement)
117 | 		: _node;
118 | 	return tsm.Node.isExportable(node) ? node : undefined;
119 | };
120 | 
121 | export function isExportable<T extends tsm.Node>(
122 | 	node: T,
123 | ): node is T & tsm.ExportableNode {
124 | 	return !!getExportableNode(node);
125 | }
126 | 
127 | export const isJsDocChild = (node: tsm.Node) => {
128 | 	return node.getAncestors().some((ancestor) => tsm.Node.isJSDoc(ancestor));
129 | };
130 | 
131 | const _nodeIdCache = new Map<tsm.Node, tsm.Node>();
132 | export const getNodeId = (node: tsm.Node) => {
133 | 	if (_nodeIdCache.has(node)) {
134 | 		return _nodeIdCache.get(node)!;
135 | 	}
136 | 	for (const id of node.getDescendantsOfKind(tsm.SyntaxKind.Identifier)) {
137 | 		if (!isJsDocChild(id)) {
138 | 			_nodeIdCache.set(node, id);
139 | 			return id;
140 | 		}
141 | 	}
142 | 	return null;
143 | };
144 | 
145 | function findChildrenOfKindById(needle: tsm.Node, haystack: tsm.Node) {
146 | 	const needleId = getNodeId(needle);
147 | 	if (needleId) {
148 | 		const kind = needle.getKind();
149 | 		const children = haystack.getChildrenOfKind(kind);
150 | 		for (const child of children) {
151 | 			const childId = getNodeId(child);
152 | 			if (childId && needleId.getText() === childId.getText()) {
153 | 				return child;
154 | 			}
155 | 		}
156 | 	}
157 | 
158 | 	return null;
159 | }
160 | 
161 | /**
162 |  * Simplified node type index file resolution.
163 |  */
164 | const getFileFromModulePath = (project: tsm.Project, modulePath: string) => {
165 | 	let file = project.getSourceFile(`${modulePath}.ts`);
166 | 	if (!file) {
167 | 		file = project.getSourceFile(`${modulePath}.tsx`);
168 | 	}
169 | 	if (!file) {
170 | 		file = project.getSourceFile(`${modulePath}/index.ts`);
171 | 	}
172 | 	if (!file) {
173 | 		file = project.getSourceFile(`${modulePath}/index.tsx`);
174 | 	}
175 | 	return file;
176 | };
177 | 
178 | const _forget = new Set<tsm.ImportTypeNode>();
179 | 
180 | export const replaceTransientImport = (
181 | 	{
182 | 		node,
183 | 		sourceFile,
184 | 		declarationFile,
185 | 	}: {
186 | 		node: tsm.ImportTypeNode;
187 | 		sourceFile: tsm.SourceFile;
188 | 		declarationFile: tsm.SourceFile;
189 | 	},
190 | 	inProject: tsm.Project,
191 | 	diagnostics: Diagnostic,
192 | ) => {
193 | 	const literal = node.getFirstDescendantByKind(tsm.SyntaxKind.StringLiteral)!;
194 | 	const file = resolveModule(
195 | 		literal.getLiteralValue(),
196 | 		sourceFile.getDirectoryPath(),
197 | 		inProject,
198 | 	);
199 | 	if (file) {
200 | 		// find the node with the id and add to work items
201 | 		const importedNode = findChildrenOfKindById(
202 | 			node,
203 | 			file,
204 | 			// [...file.getExportedDeclarations().values()].flat()
205 | 		);
206 | 
207 | 		// strip the import type
208 | 		const nodeText = getNodeId(node)!.getText();
209 | 		node.replaceWithText(nodeText);
210 | 
211 | 		// add a @transient tag to the imported node for additional clarity
212 | 		if (
213 | 			!hasJsDocTag(importedNode, "transient") &&
214 | 			tsm.Node.isJSDocable(importedNode)
215 | 		) {
216 | 			importedNode.addJsDoc({
217 | 				description: `@transient`,
218 | 			});
219 | 		}
220 | 		return importedNode;
221 | 	} else {
222 | 		//TODO if the transient import is external, eg zustand
223 | 		// we need to add the identifier to imports
224 | 		diagnostics.importFileNotFound.add(literal.getLiteralValue());
225 | 		return null;
226 | 	}
227 | };
228 | 
229 | /**
230 |  * Replace transient imports with regular imports.
231 |  *
232 |  * Transient imports are added by typescript like type A = import("a").A which we strip and add
233 |  * as regular imports.
234 |  *
235 |  * @returns
236 |  */
237 | export const replaceTransientImports = (
238 | 	declarationFile: tsm.SourceFile,
239 | 	sourceFile: tsm.SourceFile,
240 | 	inProject: tsm.Project,
241 | 	diagnostics: Diagnostic,
242 | ) => {
243 | 	return [
244 | 		...new Set(
245 | 			declarationFile
246 | 				.getDescendantsOfKind(tsm.SyntaxKind.ImportType)
247 | 				.map((importType) => {
248 | 					return replaceTransientImport(
249 | 						{
250 | 							node: importType,
251 | 							sourceFile,
252 | 							declarationFile,
253 | 						},
254 | 						inProject,
255 | 						diagnostics,
256 | 					);
257 | 				})
258 | 				.filter((x) => x),
259 | 		),
260 | 	];
261 | };
262 | 
263 | /**
264 |  * Resolves module path based on cwd similar to node. Respects aliases.
265 |  *
266 |  * @param baseModulePath Module identifier to be imported
267 |  * @param cwd File directory that is importing the module
268 |  * @param project Project
269 |  * @returns SourceFile | null
270 |  */
271 | export const resolveModule = (
272 | 	baseModulePath: string,
273 | 	cwd: string,
274 | 	project: tsm.Project,
275 | ) => {
276 | 	let file: tsm.SourceFile | undefined;
277 | 
278 | 	const projectUrl = project.getCompilerOptions().baseUrl || "";
279 | 	const paths = project.getCompilerOptions().paths || {};
280 | 
281 | 	const alias = Object.keys(paths).find((alias) =>
282 | 		baseModulePath.startsWith(alias.replace("*", "")),
283 | 	);
284 | 
285 | 	if (alias) {
286 | 		for (const path of paths[alias]) {
287 | 			const modulePath = join(
288 | 				projectUrl,
289 | 				baseModulePath.replace(alias.replace("*", ""), path.replace("*", "")),
290 | 			);
291 | 			file = getFileFromModulePath(project, modulePath);
292 | 			if (file) {
293 | 				break;
294 | 			}
295 | 		}
296 | 	} else {
297 | 		file = getFileFromModulePath(project, resolve(cwd, baseModulePath));
298 | 	}
299 | 
300 | 	if (file) {
301 | 		return file;
302 | 	}
303 | 	return null;
304 | };
305 | 
306 | /**
307 |  * Whether the node definition is external to the project
308 |  */
309 | export const isExternalNode = (node: tsm.Node) => {
310 | 	return (
311 | 		node.getSourceFile().isInNodeModules() ||
312 | 		node.getSourceFile().isFromExternalLibrary()
313 | 	);
314 | };
315 | 
316 | /**
317 |  * Gets the definition nodes for a given node identifier
318 |  *
319 |  * @param id The node identifier to get the definition nodes for
320 |  * @param project
321 |  * @param allowExternal
322 |  * @returns
323 |  */
324 | export const getDefinitionNodes = (
325 | 	id: tsm.Identifier,
326 | 	project: tsm.Project,
327 | 	allowExternal = false,
328 | ) => {
329 | 	let definitionNodes = id.getDefinitionNodes().filter((def) => {
330 | 		if (allowExternal) return true;
331 | 		return (
332 | 			!def.getSourceFile().isInNodeModules() &&
333 | 			!def.getSourceFile().isFromExternalLibrary()
334 | 		);
335 | 	});
336 | 
337 | 	// sometimes definition nodes are not found because they are external
338 | 	// othertimes they are not found for some reason and we need to get it from the symbol
339 | 	if (id.getDefinitionNodes().length === 0) {
340 | 		const definitions = id.getDefinitions();
341 | 
342 | 		for (const definition of definitions) {
343 | 			const file = project.getSourceFile(
344 | 				definition.getSourceFile().getFilePath(),
345 | 			);
346 | 			if (file) {
347 | 				if (
348 | 					!allowExternal &&
349 | 					(file.isInNodeModules() || file.isFromExternalLibrary())
350 | 				) {
351 | 					continue;
352 | 				}
353 | 				file.forEachDescendant((child) => {
354 | 					//TODO: should get type + identifier
355 | 					if (
356 | 						getNodeId(child) &&
357 | 						getNodeId(child)!.getText() === id.getText()
358 | 					) {
359 | 						definitionNodes.push(child);
360 | 					}
361 | 				});
362 | 			}
363 | 		}
364 | 	}
365 | 	return definitionNodes;
366 | };
367 | 
368 | export const isReferencedByAncestorDeclaration = (
369 | 	node: tsm.Node,
370 | 	srcDeclNode: tsm.Node,
371 | ) => {
372 | 	const id = getNodeId(node)!.getText();
373 | 	let _declParent = srcDeclNode;
374 | 
375 | 	while (_declParent.getParent()) {
376 | 		_declParent = _declParent.getParent();
377 | 	}
378 | 
379 | 	for (const _decl of _declParent.getDescendantsOfKind(node.getKind())) {
380 | 		for (const _id of _decl.getChildrenOfKind(tsm.SyntaxKind.Identifier)) {
381 | 			if (_id.getText() === id) {
382 | 				return true;
383 | 			}
384 | 		}
385 | 	}
386 | 	return false;
387 | };
388 | 
389 | /**
390 |  * For variable declaration node types we actually want the parent variable statement node type since that is exportable
391 |  * All other nodes are returned as is
392 |  */
393 | export const getStatement = (node: tsm.Node) => {
394 | 	if (tsm.Node.isVariableDeclaration(node)) {
395 | 		return node.getFirstAncestorByKindOrThrow(tsm.SyntaxKind.VariableStatement);
396 | 	}
397 | 
398 | 	return node;
399 | };
400 | 
401 | type OutputNodeTextOptions = {
402 | 	wrapInGlobal?: string[];
403 | 	defaultInternal?: boolean;
404 | };
405 | 
406 | export const outputNodeText = (
407 | 	declNode: tsm.Node,
408 | 	sourceFile: tsm.SourceFile,
409 | 	result: {
410 | 		global: string;
411 | 		content: string;
412 | 	},
413 | 	opts: OutputNodeTextOptions,
414 | ) => {
415 | 	const outputNode = getStatement(declNode);
416 | 
417 | 	if (
418 | 		opts.wrapInGlobal &&
419 | 		opts.wrapInGlobal.includes(getNodeId(declNode)!.getText())
420 | 	) {
421 | 		if (
422 | 			(declNode as tsm.ClassDeclaration).isAmbient &&
423 | 			(declNode as tsm.ClassDeclaration).isAmbient()
424 | 		) {
425 | 			(declNode as tsm.ClassDeclaration).setHasDeclareKeyword(false);
426 | 		}
427 | 		if (isExportable(declNode)) {
428 | 			result.global +=
429 | 				`\n\n//${sourceFile.getFilePath()}\n` + outputNode.getFullText();
430 | 		} else {
431 | 			throw new Error("Cannot wrap in global if not exportable");
432 | 		}
433 | 	} else {
434 | 		if (tsm.Node.isJSDocable(outputNode) && tsm.Node.isExportable(outputNode)) {
435 | 			if (
436 | 				opts.defaultInternal &&
437 | 				!hasJsDocTag(outputNode, "public") &&
438 | 				!hasJsDocTag(outputNode, "internal")
439 | 			) {
440 | 				outputNode.addJsDoc("@internal");
441 | 			}
442 | 
443 | 			if (hasJsDocTag(outputNode, "internal")) {
444 | 				outputNode.setIsExported(false);
445 | 			}
446 | 		}
447 | 		result.content +=
448 | 			`\n\n//${sourceFile.getFilePath()}\n` + outputNode.getFullText();
449 | 	}
450 | };
451 | 
452 | /**
453 |  * Gets the declaration node for a given definition node.
454 |  * These are matched naively by kind and identifier name
455 |  */
456 | export const getDeclarationNode = (
457 | 	node: tsm.Node,
458 | 	inProject: tsm.Project,
459 | 	outProject: tsm.Project,
460 | ) => {
461 | 	if (hasOwnIdentifier(node)) {
462 | 		const nodeDecl = emitFileDeclaration(
463 | 			inProject,
464 | 			node.getSourceFile(),
465 | 			outProject,
466 | 		);
467 | 
468 | 		return findChildrenOfKindById(node, nodeDecl);
469 | 	}
470 | 	return null;
471 | };


--------------------------------------------------------------------------------
/src/utils/ux/progress_bar.ts:
--------------------------------------------------------------------------------
 1 | import { MultiBar, Presets } from 'cli-progress';
 2 | 
 3 | export const progress_bar = new MultiBar(
 4 |   {
 5 |     clearOnComplete: false,
 6 |     hideCursor: true,
 7 |     format: ' {bar} | {filename} | {value}/{total}'
 8 |   },
 9 |   Presets.shades_grey
10 | );
11 | 


--------------------------------------------------------------------------------
/src/utils/ux/spinner.ts:
--------------------------------------------------------------------------------
1 | import ora from "ora";
2 | 
3 | export const spinner = ora({ color: "yellow" });
4 | 


--------------------------------------------------------------------------------
/src/utils/writers.ts:
--------------------------------------------------------------------------------
1 | // generic function that wraps a function output in brackets
2 | export function brackets<T extends string>(string: T): `{${T}}\n` {
3 | 	return `{${string}}\n`;
4 | }
5 | 
6 | export function newline<T extends string>(string: T): `${T}\n` {
7 | 	return `${string}\n`;
8 | }
9 | 


--------------------------------------------------------------------------------
/static/api/schemas/swagger.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"openapi": "3.0.0",
  3 | 	"components": {
  4 | 		"examples": {},
  5 | 		"headers": {},
  6 | 		"parameters": {},
  7 | 		"requestBodies": {},
  8 | 		"responses": {},
  9 | 		"schemas": {
 10 | 			"UserId": {
 11 | 				"type": "string"
 12 | 			},
 13 | 			"Record_never.never_": {
 14 | 				"properties": {},
 15 | 				"type": "object",
 16 | 				"description": "Construct a type with a set of properties K of type T"
 17 | 			},
 18 | 			"Session": {
 19 | 				"properties": {
 20 | 					"id": {
 21 | 						"type": "string"
 22 | 					},
 23 | 					"expiresAt": {
 24 | 						"type": "string",
 25 | 						"format": "date-time"
 26 | 					},
 27 | 					"fresh": {
 28 | 						"type": "boolean"
 29 | 					},
 30 | 					"userId": {
 31 | 						"$ref": "#/components/schemas/UserId"
 32 | 					}
 33 | 				},
 34 | 				"required": [
 35 | 					"id",
 36 | 					"expiresAt",
 37 | 					"fresh",
 38 | 					"userId"
 39 | 				],
 40 | 				"type": "object",
 41 | 				"additionalProperties": false
 42 | 			},
 43 | 			"SolanaSignInInput": {
 44 | 				"properties": {
 45 | 					"proof": {
 46 | 						"type": "string"
 47 | 					},
 48 | 					"account": {
 49 | 						"properties": {
 50 | 							"label": {
 51 | 								"type": "string"
 52 | 							},
 53 | 							"icon": {
 54 | 								"type": "string"
 55 | 							},
 56 | 							"address": {
 57 | 								"type": "string"
 58 | 							}
 59 | 						},
 60 | 						"required": [
 61 | 							"label",
 62 | 							"icon",
 63 | 							"address"
 64 | 						],
 65 | 						"type": "object"
 66 | 					}
 67 | 				},
 68 | 				"required": [
 69 | 					"proof",
 70 | 					"account"
 71 | 				],
 72 | 				"type": "object"
 73 | 			},
 74 | 			"SerializedSolanaSignInOutput": {
 75 | 				"properties": {
 76 | 					"signature": {
 77 | 						"type": "string"
 78 | 					},
 79 | 					"account": {
 80 | 						"properties": {
 81 | 							"label": {
 82 | 								"type": "string"
 83 | 							},
 84 | 							"icon": {
 85 | 								"type": "string"
 86 | 							},
 87 | 							"address": {
 88 | 								"type": "string"
 89 | 							}
 90 | 						},
 91 | 						"required": [
 92 | 							"label",
 93 | 							"icon",
 94 | 							"address"
 95 | 						],
 96 | 						"type": "object"
 97 | 					}
 98 | 				},
 99 | 				"required": [
100 | 					"signature",
101 | 					"account"
102 | 				],
103 | 				"type": "object"
104 | 			}
105 | 		},
106 | 		"securitySchemes": {}
107 | 	},
108 | 	"info": {
109 | 		"title": ""
110 | 	},
111 | 	"paths": {
112 | 		"/api/prisma/{id}": {
113 | 			"post": {
114 | 				"operationId": "Post",
115 | 				"responses": {
116 | 					"200": {
117 | 						"description": "Ok",
118 | 						"content": {
119 | 							"application/json": {
120 | 								"schema": {
121 | 									"$ref": "#/components/schemas/Session"
122 | 								}
123 | 							}
124 | 						}
125 | 					}
126 | 				},
127 | 				"security": [],
128 | 				"parameters": [
129 | 					{
130 | 						"in": "path",
131 | 						"name": "id",
132 | 						"required": true,
133 | 						"schema": {
134 | 							"type": "string"
135 | 						}
136 | 					},
137 | 					{
138 | 						"in": "query",
139 | 						"name": "state",
140 | 						"required": true,
141 | 						"schema": {
142 | 							"type": "string"
143 | 						}
144 | 					}
145 | 				],
146 | 				"requestBody": {
147 | 					"required": true,
148 | 					"content": {
149 | 						"application/json": {
150 | 							"schema": {
151 | 								"properties": {
152 | 									"output": {
153 | 										"$ref": "#/components/schemas/SerializedSolanaSignInOutput"
154 | 									},
155 | 									"input": {
156 | 										"$ref": "#/components/schemas/SolanaSignInInput"
157 | 									}
158 | 								},
159 | 								"required": [
160 | 									"output",
161 | 									"input"
162 | 								],
163 | 								"type": "object"
164 | 							}
165 | 						}
166 | 					}
167 | 				}
168 | 			},
169 | 			"patch": {
170 | 				"operationId": "Patch",
171 | 				"responses": {
172 | 					"200": {
173 | 						"description": "Ok",
174 | 						"content": {
175 | 							"application/json": {
176 | 								"schema": {}
177 | 							}
178 | 						}
179 | 					},
180 | 					"400": {
181 | 						"description": "",
182 | 						"content": {
183 | 							"application/json": {
184 | 								"schema": {
185 | 									"type": "string",
186 | 									"enum": [
187 | 										"Not OK"
188 | 									],
189 | 									"nullable": false
190 | 								},
191 | 								"examples": {
192 | 									"Example 1": {}
193 | 								}
194 | 							}
195 | 						}
196 | 					}
197 | 				},
198 | 				"security": [],
199 | 				"parameters": [
200 | 					{
201 | 						"in": "path",
202 | 						"name": "id",
203 | 						"required": true,
204 | 						"schema": {
205 | 							"type": "string"
206 | 						}
207 | 					},
208 | 					{
209 | 						"in": "query",
210 | 						"name": "number",
211 | 						"required": true,
212 | 						"schema": {
213 | 							"format": "double",
214 | 							"type": "number"
215 | 						}
216 | 					}
217 | 				],
218 | 				"requestBody": {
219 | 					"required": true,
220 | 					"content": {
221 | 						"application/json": {
222 | 							"schema": {
223 | 								"$ref": "#/components/schemas/Session"
224 | 							}
225 | 						}
226 | 					}
227 | 				}
228 | 			},
229 | 			"get": {
230 | 				"operationId": "Get",
231 | 				"responses": {
232 | 					"200": {
233 | 						"description": "Ok",
234 | 						"content": {
235 | 							"application/json": {
236 | 								"schema": {
237 | 									"properties": {
238 | 										"uwu": {}
239 | 									},
240 | 									"required": [
241 | 										"uwu"
242 | 									],
243 | 									"type": "object"
244 | 								}
245 | 							}
246 | 						}
247 | 					}
248 | 				},
249 | 				"security": [],
250 | 				"parameters": [
251 | 					{
252 | 						"in": "path",
253 | 						"name": "id",
254 | 						"required": true,
255 | 						"schema": {
256 | 							"type": "string"
257 | 						}
258 | 					},
259 | 					{
260 | 						"in": "query",
261 | 						"name": "number",
262 | 						"required": true,
263 | 						"schema": {
264 | 							"format": "double",
265 | 							"type": "number"
266 | 						}
267 | 					}
268 | 				]
269 | 			}
270 | 		}
271 | 	},
272 | 	"servers": [
273 | 		{
274 | 			"url": "/api"
275 | 		}
276 | 	]
277 | }


--------------------------------------------------------------------------------
/tests/dependencies.ts:
--------------------------------------------------------------------------------
 1 | import * as fs from 'fs';
 2 | import * as path from 'path';
 3 | import {default as detective} from 'detective-es6';
 4 | import * as packageJson from '../package.json';
 5 | import { fileURLToPath } from 'url';
 6 | import { dirname } from 'path';
 7 | 
 8 | const __filename = fileURLToPath(import.meta.url);
 9 | const __dirname = dirname(__filename);
10 | 
11 | function checkDependencies(filePath) {
12 |     const fileContent = fs.readFileSync(filePath, 'utf-8');
13 |     const requires = detective(fileContent);
14 |     const packageDependencies = Object.keys(packageJson.dependencies || {});
15 | 
16 |     const missing = requires.filter(dep => {
17 |         // Ignore relative imports.
18 |         if (dep.startsWith('.') || dep.startsWith('/')) {
19 |             return false;
20 |         }
21 | 
22 |         return !packageDependencies.includes(dep);
23 |     });
24 | 
25 |     if (missing.length > 0) {
26 |         console.log(`The following dependencies are used in ${filePath} but not listed in package.json: `);
27 |         console.log(missing.join('\n'));
28 |     } else {
29 |         console.log(`All dependencies in ${filePath} are listed in package.json.`);
30 |     }
31 | }
32 | 
33 | // Replace 'yourScript.js' with the path to your script file.
34 | checkDependencies(path.resolve(__dirname, '../src/generator.ts'));
35 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "@total-typescript/tsconfig/tsc/dom/library",
 3 |   "include": ["src/"],
 4 |   "exclude": ["dist", "node_modules"],
 5 |   "compilerOptions": {
 6 |     "paths": {
 7 |       "@/*": ["./src/*"]
 8 |     },
 9 |     "rootDir": "./src",
10 |     "outDir": "./dist",
11 |     "lib": ["ESNext"],
12 |     "target": "ESNext",
13 |     "module": "NodeNext",
14 |     "moduleResolution": "NodeNext",
15 |     "moduleDetection": "force",
16 |     "allowJs": true,
17 |     "esModuleInterop": true,
18 |     "allowSyntheticDefaultImports": true,
19 |     "strict": true,
20 |     "skipLibCheck": true,
21 |     "noFallthroughCasesInSwitch": true,
22 |     "resolveJsonModule": true,
23 |     "declaration": true,
24 |     "sourceMap": true,
25 |     "experimentalDecorators": true
26 |   }
27 | }


--------------------------------------------------------------------------------