@skmtc/core 0.0.828 → 0.0.830

package/README.md

@@ -1,89 +1,116 @@
-[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
-[![Deno](https://img.shields.io/badge/Deno-2.5+-green.svg)](https://deno.land/)
-[![Discord](https://img.shields.io/badge/Discord-join%20chat-1dce73.svg)](https://discord.com/invite/Mg88C8Xu5Y)
-
 <p align="center">
-  <img src="https://raw.githubusercontent.com/skmtc/skmtc/refs/heads/main/skmtc.svg" />
+  <img src="./skmtc.svg" />
 </p>
 
-## Problems We Solve
-
-**Stop writing the same code over and over.** Generate TypeScript types, API clients, validation schemas, and more directly from your OpenAPI specifications.
+**Skmtc is a declarative code generation framework**. It lets you generate TypeScript code from OpenAPI schemas. Specify the exact output you want using string templates and get it in seconds.
 
-### Manual Type Definitions
-**Pain:** Hours spent manually writing TypeScript interfaces from OpenAPI docs, fighting typos and sync issues.  
-**Solution:** Generate accurate types with perfect synchronization.
+## ✨ Features
 
-### Schema Evolution Management
-**Pain:** API changes break frontend types, validation, mocks, and docs across dozens of files.  
-**Solution:** Single regeneration command updates all artifacts simultaneously.
+- 🏎️ **Fast** - Generates 550k+ tokens per second
+- 🧵 **Easy to edit code generators** - Outputs specified using string templates, not ASTs
+- 🥞 **Stackable generators** - Combine multiple generators to generate deep functionality
+- 🗄️ **Use your own code conventions** - Full control over naming and file structure
 
-### Type-Unsafe Runtime API Integration  
-**Pain:** No compile-time guarantees that API calls match backend schemas.  
-**Solution:** End-to-end type safety from schema through clients to UI components.
+## 🚀 Quick Start
 
-## Quick Start
+```bash
+# Run directly with npx
+npx skmtc
 
-**Learning Outcome:** Generate TypeScript types from an OpenAPI schema in 5 minutes.
+```
 
-### Install
+### Running code generators
 
 ```bash
-# Import in your Deno project
-import { toArtifacts } from "jsr:@skmtc/core"
+npx skmtc generate @skmtc/supabase-backend https://petstore3.swagger.io/api/v3/openapi.json
+# Generated 9 files (507 lines, 3,383 tokens) in 9ms
+
+npx skmtc generate @skmtc/supabase-react-client https://raw.githubusercontent.com/cloudflare/api-schemas/refs/heads/main/openapi.json
+# Generated 6,797 files (104,752 lines, 1,635,227 tokens) in 2,969ms
 ```
 
-### Generate Types
+### Example generator code
 
 ```typescript
-import { toArtifacts } from "@skmtc/core"
-import typescriptGenerator from "@skmtc/gen-typescript"
-
-// Your OpenAPI v3 schema
-const schema = {
-  openapi: "3.0.0",
-  info: { title: "API", version: "1.0.0" },
-  components: {
-    schemas: {
-      User: {
-        type: "object",
-        properties: {
-          id: { type: "string" },
-          name: { type: "string" }
-        }
-      }
-    }
+import { ZodInsertable } from '@skmtc/gen-zod'
+
+class ZodFetch extends BaseTransformer {
+  zodName: string;
+
+  constructor({context, operation, settings}){
+    super({context, operation, settings})
+
+    // Generate Zod schema for API response and insert it into current file
+    const response = operation.toSuccessResponse()?.resolve().toSchema()
+    const zodResponse = this.insert(ZodInsertable, response)
+
+    // Grab Zod schema name to use in output code
+    this.zodName = zodResponse.identifier.name
   }
-}
 
-// Generate TypeScript types
-const artifacts = await toArtifacts({
-  schema,
-  generators: [typescriptGenerator]
-})
+  // Define code output
+  toString(){
+    return `() => {
+      const res = await fetch('${this.operation.path}')
+      const data = await res.json()
 
-// Write generated files
-for (const [path, content] of artifacts) {
-  await Deno.writeTextFile(path, content)
+      return ${zodName}.parse(data)
+    }`
+  }
 }
 ```
 
-### Result
+## 📦 Available Generators
 
-```typescript
-// @/types/user.generated.ts
-export interface User {
-  id?: string
-  name?: string
-}
-```
+Choose from our growing collection of generators, combone them or create your own:
 
-## What's Next
+- **Tanstack Query** - React Query hooks with Zod validation
+- **MSW** - Mock Service Worker handlers from OpenAPI examples
+- **Zod Schemas** - Runtime validation schemas
+- **TypeScript Types** - Pure type definitions
+- **Supabase/Hono Functions** - Edge function handlers
+- See full list at https://github.com/skmtc/skmtc-generators
 
-- **[Getting Started →](docs/getting-started/installation.md)** - Complete setup guide
-- **[How-To Guides →](docs/how-to/)** - Task-oriented tutorials  
-- **[API Reference →](docs/api/)** - Complete technical documentation
+## ❓ FAQ
 
-## License
+### **What OpenAPI versions are supported?**
+Skmtc supports OpenAPI v3.0. Swagger 2.0 and OpenAPI v3.1 are automatically converted to OpenAPI v3.0.
 
-[Apache-2.0](LICENSE)
+### **Can I customize the generated code?**
+Yes! Each Transformer specifies its output using plain string templates, which means you can
+edit them as would you edit any other code.
+
+### **Can I use this with my existing React app?**
+Yes! Skmtc generates standalone code that integrates with any React application. The generated components work with your existing setup.
+
+### **How does this compare to OpenAPI Generator?**
+Skmtc is the only code generation framework that provides full control over the generated code. You are not limited by library-specific settings and you do not need to write complex AST code.
+
+### **Does it work with Next.js/Remix/Vite?**
+Yes! The generated code is framework-agnostic TypeScript that works with any build tool or library.
+
+## 🤝 Contributing
+
+We welcome contributions! Check out our [Contributing Guide](CONTRIBUTING.md) to get started.
+
+<!-- ## 📚 Documentation
+
+- [Full Documentation](https://docs.skmtc.dev)
+- [API Reference](https://docs.skmtc.dev/api)
+- [Custom Generators Guide](https://docs.skmtc.dev/generators)
+- [Examples](https://github.com/skmtc/skmtc/tree/main/examples) -->
+
+## 🛟 Support
+
+- [GitHub Issues](https://github.com/skmtc/skmtc/issues) - Bug reports and feature requests
+- [Discord Community](https://discord.com/invite/Mg88C8Xu5Y) - Get help and share your experience
+
+## 📄 License
+
+Apache 2.0 © [Skmtc Contributors](LICENSE.md)
+
+---
+
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Deno](https://img.shields.io/badge/Deno-2.5+-green.svg)](https://deno.land/)
+[![Discord](https://img.shields.io/badge/Discord-join%20chat-1dce73.svg)](https://discord.com/invite/Mg88C8Xu5Y)

package/esm/helpers/strings.d.ts

@@ -77,6 +77,8 @@ export declare const decapitalize: (str: string) => string;
 type CamelCaseOptions = {
     /** Whether to capitalize the first character (PascalCase) */
     upperFirst?: boolean;
+    /** Whether to retain underscores in place when converting strings */
+    retainUnderscores?: boolean;
 };
 /**
  * Converts a string to camelCase, removing non-alphanumeric characters.
@@ -88,6 +90,7 @@ type CamelCaseOptions = {
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -110,7 +113,15 @@ type CamelCaseOptions = {
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-export declare const camelCase: (str: string, { upperFirst }?: CamelCaseOptions) => string;
+export declare const camelCase: (str: string, { upperFirst, retainUnderscores }?: CamelCaseOptions) => string;
 export {};
 //# sourceMappingURL=strings.d.ts.map

package/esm/helpers/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,iBAAgB,gBAAqB,KAAG,MAgB9E,CAAA"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,oCAAmC,gBAAqB,KAAG,MA+BjG,CAAA"}

package/esm/helpers/strings.js

@@ -85,6 +85,7 @@ export const decapitalize = (str) => {
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -107,16 +108,38 @@ export const decapitalize = (str) => {
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-export const camelCase = (str, { upperFirst } = {}) => {
-    let doCapitalize = Boolean(upperFirst);
-    const camelCased = str.replace(/[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g, (_, matched) => {
-        if (doCapitalize) {
-            return capitalize(matched);
+export const camelCase = (str, { upperFirst, retainUnderscores } = {}) => {
+    // Check if string starts with a delimiter
+    const startsWithDelimiter = retainUnderscores
+        ? /^[^a-zA-Z0-9_]/.test(str) // Non-alphanumeric except underscore
+        : /^[^a-zA-Z0-9]/.test(str); // Non-alphanumeric including underscore
+    let isFirstMatch = true;
+    // Determine delimiter pattern based on retainUnderscores
+    const delimiterPattern = retainUnderscores
+        ? /[^a-zA-Z0-9_]+([a-zA-Z0-9_]+)/g // Treat underscore as regular character
+        : /[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g; // Treat underscore as delimiter
+    const camelCased = str.replace(delimiterPattern, (_, matched) => {
+        // If string starts with delimiter and this is the first match:
+        // - Capitalize only if upperFirst is true
+        // Otherwise, always capitalize (word comes after delimiter)
+        if (isFirstMatch && startsWithDelimiter && !upperFirst) {
+            isFirstMatch = false;
+            return matched;
         }
-        doCapitalize = true;
-        return matched;
+        isFirstMatch = false;
+        return capitalize(matched);
     });
-    const cleaned = camelCased.replaceAll(/[^a-z0-9]*/gi, '');
+    // Clean non-alphanumeric characters (preserving underscores if retainUnderscores)
+    const cleanPattern = retainUnderscores ? /[^a-zA-Z0-9_]/g : /[^a-zA-Z0-9]/g;
+    const cleaned = camelCased.replace(cleanPattern, '');
     return upperFirst ? capitalize(cleaned) : cleaned;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.0.828",
+  "version": "0.0.830",
   "description": "Skmtc is a declarative code generation framework",
   "keywords": [
     "openapi",

package/script/helpers/strings.d.ts

@@ -77,6 +77,8 @@ export declare const decapitalize: (str: string) => string;
 type CamelCaseOptions = {
     /** Whether to capitalize the first character (PascalCase) */
     upperFirst?: boolean;
+    /** Whether to retain underscores in place when converting strings */
+    retainUnderscores?: boolean;
 };
 /**
  * Converts a string to camelCase, removing non-alphanumeric characters.
@@ -88,6 +90,7 @@ type CamelCaseOptions = {
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -110,7 +113,15 @@ type CamelCaseOptions = {
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-export declare const camelCase: (str: string, { upperFirst }?: CamelCaseOptions) => string;
+export declare const camelCase: (str: string, { upperFirst, retainUnderscores }?: CamelCaseOptions) => string;
 export {};
 //# sourceMappingURL=strings.d.ts.map

package/script/helpers/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,iBAAgB,gBAAqB,KAAG,MAgB9E,CAAA"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,oCAAmC,gBAAqB,KAAG,MA+BjG,CAAA"}

package/script/helpers/strings.js

@@ -90,6 +90,7 @@ exports.decapitalize = decapitalize;
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -112,17 +113,39 @@ exports.decapitalize = decapitalize;
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-const camelCase = (str, { upperFirst } = {}) => {
-    let doCapitalize = Boolean(upperFirst);
-    const camelCased = str.replace(/[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g, (_, matched) => {
-        if (doCapitalize) {
-            return (0, exports.capitalize)(matched);
+const camelCase = (str, { upperFirst, retainUnderscores } = {}) => {
+    // Check if string starts with a delimiter
+    const startsWithDelimiter = retainUnderscores
+        ? /^[^a-zA-Z0-9_]/.test(str) // Non-alphanumeric except underscore
+        : /^[^a-zA-Z0-9]/.test(str); // Non-alphanumeric including underscore
+    let isFirstMatch = true;
+    // Determine delimiter pattern based on retainUnderscores
+    const delimiterPattern = retainUnderscores
+        ? /[^a-zA-Z0-9_]+([a-zA-Z0-9_]+)/g // Treat underscore as regular character
+        : /[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g; // Treat underscore as delimiter
+    const camelCased = str.replace(delimiterPattern, (_, matched) => {
+        // If string starts with delimiter and this is the first match:
+        // - Capitalize only if upperFirst is true
+        // Otherwise, always capitalize (word comes after delimiter)
+        if (isFirstMatch && startsWithDelimiter && !upperFirst) {
+            isFirstMatch = false;
+            return matched;
         }
-        doCapitalize = true;
-        return matched;
+        isFirstMatch = false;
+        return (0, exports.capitalize)(matched);
     });
-    const cleaned = camelCased.replaceAll(/[^a-z0-9]*/gi, '');
+    // Clean non-alphanumeric characters (preserving underscores if retainUnderscores)
+    const cleanPattern = retainUnderscores ? /[^a-zA-Z0-9_]/g : /[^a-zA-Z0-9]/g;
+    const cleaned = camelCased.replace(cleanPattern, '');
     return upperFirst ? (0, exports.capitalize)(cleaned) : cleaned;
 };
 exports.camelCase = camelCase;