cdk-from-cfn 0.270.0 → 0.272.0

package/README.md

@@ -11,11 +11,29 @@ cargo install cdk-from-cfn
 ## Usage
 
 ```console
-cdk-from-cfn [INPUT] [OUTPUT] --language <LANGUAGE> --stack-name <STACK_NAME>
+cdk-from-cfn [INPUT] [OUTPUT] --language <LANGUAGE> --stack-name <STACK_NAME> [--as <stack|construct>]
 ```
 
 - `INPUT` is the input file path (STDIN by default).
 - `OUTPUT` is the output file path; if not specified, output will be printed on your command line (STDOUT by default).
+- `--as` (optional) specifies the output type: `stack` (default) or `construct`. Use `construct` to generate a reusable CDK construct instead of a standalone stack.
+
+### Class Type Option
+
+By default, cdk-from-cfn generates code that extends `Stack`. You can use the `--as` flag to generate a reusable `Construct` instead:
+
+```console
+# Generate a Stack (default)
+cdk-from-cfn template.json --language typescript --as stack
+
+# Generate a Construct
+cdk-from-cfn template.json --language typescript --as construct
+```
+
+When using `construct` mode:
+- The generated class extends `Construct` instead of `Stack`
+- Props interface does not extend `StackProps`
+- Pseudo-parameters like `AWS::StackName` use `Stack.of(this)` to access the parent stack
 
 ## Node.js Module Usage
 
@@ -27,10 +45,17 @@ import * as cdk_from_cfn from 'cdk-from-cfn';
 // get supported languages
 cdk_from_cfn.supported_languages();
 
-// transmute cfn template into cdk app
-cdk_from_cfn.transmute(template, language, stackName)
+// transmute cfn template into cdk app (generates a Stack by default)
+cdk_from_cfn.transmute(template, language, stackName);
+
+// transmute cfn template into a reusable Construct
+cdk_from_cfn.transmute(template, language, stackName, 'construct');
 ```
 
+The `transmute` function accepts an optional fourth parameter `classType`:
+- `'stack'` (default): generates code extending `Stack`
+- `'construct'`: generates code extending `Construct`
+
 ## Language and Feature support
 
 | Name         | Enabled by default | Description                           |

package/index.d.ts

@@ -10,6 +10,6 @@ export function supported_languages(): any[];
  * Transforms the provided template into a CDK application in the specified
  * language.
  */
-export function transmute(template: string, language: string, stack_name: string): string;
+export function transmute(template: string, language: string, class_name: string, class_type?: string | null): string;
 
 export function wasm_init(): void;

package/index.js

@@ -34,6 +34,10 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -115,31 +119,34 @@ exports.supported_languages = supported_languages;
  * language.
  * @param {string} template
  * @param {string} language
- * @param {string} stack_name
+ * @param {string} class_name
+ * @param {string | null} [class_type]
  * @returns {string}
  */
-function transmute(template, language, stack_name) {
-    let deferred5_0;
-    let deferred5_1;
+function transmute(template, language, class_name, class_type) {
+    let deferred6_0;
+    let deferred6_1;
     try {
         const ptr0 = passStringToWasm0(template, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(language, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(stack_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr2 = passStringToWasm0(class_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.transmute(ptr0, len0, ptr1, len1, ptr2, len2);
-        var ptr4 = ret[0];
-        var len4 = ret[1];
+        var ptr3 = isLikeNone(class_type) ? 0 : passStringToWasm0(class_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.transmute(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var ptr5 = ret[0];
+        var len5 = ret[1];
         if (ret[3]) {
-            ptr4 = 0; len4 = 0;
+            ptr5 = 0; len5 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred5_0 = ptr4;
-        deferred5_1 = len4;
-        return getStringFromWasm0(ptr4, len4);
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
     } finally {
-        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
     }
 }
 exports.transmute = transmute;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cdk-from-cfn",
   "description": "Turn AWS CloudFormation templates into AWS CDK applications",
-  "version": "0.270.0",
+  "version": "0.272.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",