@algorandfoundation/algokit-client-generator 3.0.6 → 4.0.0-alpha.1

package/README.md

@@ -1,6 +1,6 @@
 # AlgoKit TypeScript client generator (algokit-client-generator-ts)
 
-This project generates a type-safe smart contract client in TypeScript for the Algorand Blockchain that wraps the [application client](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/app-client.md) in [AlgoKit Utils](https://github.com/algorandfoundation/algokit-utils-ts) and tailors it to a specific smart contract. It does this by reading an [ARC-0032](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec file and generating a client which exposes methods for each ABI method in the target smart contract, along with helpers to create, update, and delete the application.
+This project generates a type-safe smart contract client in TypeScript for the Algorand Blockchain that wraps the [application client](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/app-client.md) in [AlgoKit Utils](https://github.com/algorandfoundation/algokit-utils-ts) and tailors it to a specific smart contract. It does this by reading an [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) or [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec file and generating a client which exposes methods for each ABI method in the target smart contract, along with helpers to create, update, and delete the application.
 
 ## Usage
 
@@ -12,6 +12,8 @@ To be able to consume the generated file you need to include it in a TypeScript
 npm install @algorandfoundation/algokit-utils
 ```
 
+Note: you need at least version 7 of AlgoKit Utils to work with the latest version of the generator. It currently only works with algosdk v2.
+
 ### Use
 
 The cli can be used to generate a client via the following command.
@@ -48,7 +50,7 @@ For details on how to use the generated client see the more detailed [usage docs
 
 ## Examples
 
-There are a range of [examples](./examples) that you can look at to see a source smart contract (`{contract.py}`), the generated client (`client.ts`) and some tests that demonstrate how you can use the client (`client.spec.ts`).
+There are a range of [examples](./examples) that you can look at to see a source smart contract (e.g. `{contract.py}`), the generated client (`client.ts`) and some tests that demonstrate how you can use the client (`client.spec.ts`).
 
 ## Contributing
 

package/cli.d.ts

@@ -1 +1,7 @@
 export declare function cli(workingDirectory: string, args: string[]): void;
+export declare function generateClientCommand({ application, output, preserveNames, workingDirectory, }: {
+    application: string;
+    output: string;
+    preserveNames: boolean;
+    workingDirectory: string;
+}): Promise<void>;

package/cli.js

@@ -35,23 +35,12 @@ function cli(workingDirectory, args) {
         .requiredOption('-o --output <path>', 'Specifies the output file path')
         .option('-pn --preserve-names', 'Preserve names from application.json spec instead of sanitizing them')
         .action(async ({ application, output, preserveNames }) => {
-        const fs = await import('fs');
-        const resolvedAppJsonPath = path__namespace.resolve(workingDirectory, application);
-        const resolvedOutPath = path__namespace.resolve(workingDirectory, output);
-        const resolvedOutDir = path__namespace.dirname(resolvedOutPath);
-        colorConsole.colorConsole.info `Reading application.json file from path ${resolvedAppJsonPath}`;
-        const spec = await load.loadApplicationJson(resolvedAppJsonPath);
-        colorConsole.colorConsole.info `Generating TS client for ${spec.contract.name}`;
-        const parts = generate.generate(spec, { preserveNames: Boolean(preserveNames) });
-        if (!fs.existsSync(resolvedOutDir)) {
-            colorConsole.colorConsole.warn `Output directory ${resolvedOutDir} does not exist and will be created.`;
-            fs.mkdirSync(resolvedOutDir, { recursive: true });
-        }
-        colorConsole.colorConsole.info `Writing TS client to ${resolvedOutPath}`;
-        const file = fs.createWriteStream(resolvedOutPath, {
-            flags: 'w',
+        await generateClientCommand({
+            application,
+            output,
+            preserveNames: Boolean(preserveNames),
+            workingDirectory,
         });
-        writer.writeDocumentPartsToStream(parts, file);
         colorConsole.colorConsole.success `Operation completed successfully`;
     })
         .configureOutput({
@@ -72,6 +61,48 @@ function cli(workingDirectory, args) {
         process.exit(-1);
     }
 }
+async function generateClientCommand({ application, output, preserveNames, workingDirectory, }) {
+    const fs = await import('fs');
+    const resolvedAppJsonPath = path__namespace.resolve(workingDirectory, application);
+    const resolvedOutPath = path__namespace.resolve(workingDirectory, output);
+    const resolvedOutDir = path__namespace.dirname(resolvedOutPath);
+    colorConsole.colorConsole.info `Reading application.json file from path ${resolvedAppJsonPath}`;
+    const spec = await load.loadApplicationJson(resolvedAppJsonPath);
+    colorConsole.colorConsole.info `Generating TS client for ${spec.name}`;
+    const parts = generate.generate(spec, { preserveNames });
+    if (!fs.existsSync(resolvedOutDir)) {
+        colorConsole.colorConsole.warn `Output directory ${resolvedOutDir} does not exist and will be created.`;
+        fs.mkdirSync(resolvedOutDir, { recursive: true });
+    }
+    colorConsole.colorConsole.info `Writing TS client to ${resolvedOutPath}`;
+    const file = await createAwaitableWriteStream(resolvedOutPath);
+    writer.writeDocumentPartsToStream(parts, file);
+    await file.finish();
+}
+async function createAwaitableWriteStream(path) {
+    const fs = await import('fs');
+    const stream = fs.createWriteStream(path, {
+        flags: 'w',
+    });
+    const finish = new Promise((resolve, reject) => {
+        stream.on('error', (err) => {
+            reject(err);
+        });
+        stream.on('finish', () => {
+            resolve();
+        });
+    });
+    return {
+        write(chunk) {
+            stream.write(chunk);
+        },
+        finish() {
+            stream.end();
+            return finish;
+        },
+    };
+}
 
 exports.cli = cli;
+exports.generateClientCommand = generateClientCommand;
 //# sourceMappingURL=cli.js.map

package/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sources":["../src/cli.ts"],"sourcesContent":["import { Command } from 'commander'\nimport { loadApplicationJson } from './schema/load'\nimport * as path from 'path'\nimport { generate } from './client/generate'\nimport { writeDocumentPartsToStream } from './output/writer'\nimport { colorConsole } from './util/color-console'\n\nexport function cli(workingDirectory: string, args: string[]) {\n  const program = new Command()\n  program\n    .command('generate')\n    .description('Generates a TypeScript client for the given application.json file')\n    .requiredOption('-a --application <path>', 'Specifies the application.json file')\n    .requiredOption('-o --output <path>', 'Specifies the output file path')\n    .option('-pn --preserve-names', 'Preserve names from application.json spec instead of sanitizing them')\n    .action(\n      async ({ application, output, preserveNames }: { application: string; output: string; preserveNames?: boolean }): Promise<void> => {\n        const fs = await import('fs')\n        const resolvedAppJsonPath = path.resolve(workingDirectory, application)\n        const resolvedOutPath = path.resolve(workingDirectory, output)\n        const resolvedOutDir = path.dirname(resolvedOutPath)\n        colorConsole.info`Reading application.json file from path ${resolvedAppJsonPath}`\n        const spec = await loadApplicationJson(resolvedAppJsonPath)\n        colorConsole.info`Generating TS client for ${spec.contract.name}`\n        const parts = generate(spec, { preserveNames: Boolean(preserveNames) })\n        if (!fs.existsSync(resolvedOutDir)) {\n          colorConsole.warn`Output directory ${resolvedOutDir} does not exist and will be created.`\n          fs.mkdirSync(resolvedOutDir, { recursive: true })\n        }\n        colorConsole.info`Writing TS client to ${resolvedOutPath}`\n        const file = fs.createWriteStream(resolvedOutPath, {\n          flags: 'w',\n        })\n        writeDocumentPartsToStream(parts, file)\n        colorConsole.success`Operation completed successfully`\n      },\n    )\n    .configureOutput({\n      writeErr(str: string) {\n        colorConsole.error`${str}`\n      },\n    })\n  try {\n    program.parse(args)\n  } catch (err) {\n    if (err instanceof Error) {\n      colorConsole.error`Unhandled error: \\n\\n${err.stack}`\n    } else {\n      colorConsole.error`Unhandled error: \\n\\n${err}`\n    }\n    process.exit(-1)\n  }\n}\n"],"names":["Command","path","colorConsole","loadApplicationJson","generate","writeDocumentPartsToStream"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOgB,SAAA,GAAG,CAAC,gBAAwB,EAAE,IAAc,EAAA;AAC1D,IAAA,MAAM,OAAO,GAAG,IAAIA,iBAAO,EAAE,CAAA;IAC7B,OAAO;SACJ,OAAO,CAAC,UAAU,CAAC;SACnB,WAAW,CAAC,mEAAmE,CAAC;AAChF,SAAA,cAAc,CAAC,yBAAyB,EAAE,qCAAqC,CAAC;AAChF,SAAA,cAAc,CAAC,oBAAoB,EAAE,gCAAgC,CAAC;AACtE,SAAA,MAAM,CAAC,sBAAsB,EAAE,sEAAsE,CAAC;SACtG,MAAM,CACL,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAoE,KAAmB;AAChI,QAAA,MAAM,EAAE,GAAG,MAAM,OAAO,IAAI,CAAC,CAAA;QAC7B,MAAM,mBAAmB,GAAGC,eAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAA;QACvE,MAAM,eAAe,GAAGA,eAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAA;QAC9D,MAAM,cAAc,GAAGA,eAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;AACpD,QAAAC,yBAAY,CAAC,IAAI,CAAA,CAA2C,wCAAA,EAAA,mBAAmB,EAAE,CAAA;AACjF,QAAA,MAAM,IAAI,GAAG,MAAMC,wBAAmB,CAAC,mBAAmB,CAAC,CAAA;QAC3DD,yBAAY,CAAC,IAAI,CAAA,CAA4B,yBAAA,EAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE,CAAA;AACjE,QAAA,MAAM,KAAK,GAAGE,iBAAQ,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;QACvE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;AAClC,YAAAF,yBAAY,CAAC,IAAI,CAAA,CAAoB,iBAAA,EAAA,cAAc,sCAAsC,CAAA;YACzF,EAAE,CAAC,SAAS,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;SAClD;AACD,QAAAA,yBAAY,CAAC,IAAI,CAAA,CAAwB,qBAAA,EAAA,eAAe,EAAE,CAAA;AAC1D,QAAA,MAAM,IAAI,GAAG,EAAE,CAAC,iBAAiB,CAAC,eAAe,EAAE;AACjD,YAAA,KAAK,EAAE,GAAG;AACX,SAAA,CAAC,CAAA;AACF,QAAAG,iCAA0B,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AACvC,QAAAH,yBAAY,CAAC,OAAO,CAAA,CAAA,gCAAA,CAAkC,CAAA;AACxD,KAAC,CACF;AACA,SAAA,eAAe,CAAC;AACf,QAAA,QAAQ,CAAC,GAAW,EAAA;AAClB,YAAAA,yBAAY,CAAC,KAAK,CAAA,CAAG,EAAA,GAAG,EAAE,CAAA;SAC3B;AACF,KAAA,CAAC,CAAA;AACJ,IAAA,IAAI;AACF,QAAA,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;KACpB;IAAC,OAAO,GAAG,EAAE;AACZ,QAAA,IAAI,GAAG,YAAY,KAAK,EAAE;YACxBA,yBAAY,CAAC,KAAK,CAAA,CAAA,qBAAA,EAAwB,GAAG,CAAC,KAAK,EAAE,CAAA;SACtD;aAAM;AACL,YAAAA,yBAAY,CAAC,KAAK,CAAA,CAAwB,qBAAA,EAAA,GAAG,EAAE,CAAA;SAChD;AACD,QAAA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;KACjB;AACH;;;;"}
+{"version":3,"file":"cli.js","sources":["../src/cli.ts"],"sourcesContent":["import { Command } from 'commander'\nimport { loadApplicationJson } from './schema/load'\nimport * as path from 'path'\nimport { generate } from './client/generate'\nimport { writeDocumentPartsToStream } from './output/writer'\nimport { colorConsole } from './util/color-console'\n\nexport function cli(workingDirectory: string, args: string[]) {\n  const program = new Command()\n  program\n    .command('generate')\n    .description('Generates a TypeScript client for the given application.json file')\n    .requiredOption('-a --application <path>', 'Specifies the application.json file')\n    .requiredOption('-o --output <path>', 'Specifies the output file path')\n    .option('-pn --preserve-names', 'Preserve names from application.json spec instead of sanitizing them')\n    .action(\n      async ({ application, output, preserveNames }: { application: string; output: string; preserveNames?: boolean }): Promise<void> => {\n        await generateClientCommand({\n          application,\n          output,\n          preserveNames: Boolean(preserveNames),\n          workingDirectory,\n        })\n        colorConsole.success`Operation completed successfully`\n      },\n    )\n    .configureOutput({\n      writeErr(str: string) {\n        colorConsole.error`${str}`\n      },\n    })\n  try {\n    program.parse(args)\n  } catch (err) {\n    if (err instanceof Error) {\n      colorConsole.error`Unhandled error: \\n\\n${err.stack}`\n    } else {\n      colorConsole.error`Unhandled error: \\n\\n${err}`\n    }\n    process.exit(-1)\n  }\n}\n\nexport async function generateClientCommand({\n  application,\n  output,\n  preserveNames,\n  workingDirectory,\n}: {\n  application: string\n  output: string\n  preserveNames: boolean\n  workingDirectory: string\n}) {\n  const fs = await import('fs')\n\n  const resolvedAppJsonPath = path.resolve(workingDirectory, application)\n  const resolvedOutPath = path.resolve(workingDirectory, output)\n  const resolvedOutDir = path.dirname(resolvedOutPath)\n  colorConsole.info`Reading application.json file from path ${resolvedAppJsonPath}`\n  const spec = await loadApplicationJson(resolvedAppJsonPath)\n  colorConsole.info`Generating TS client for ${spec.name}`\n  const parts = generate(spec, { preserveNames })\n  if (!fs.existsSync(resolvedOutDir)) {\n    colorConsole.warn`Output directory ${resolvedOutDir} does not exist and will be created.`\n    fs.mkdirSync(resolvedOutDir, { recursive: true })\n  }\n  colorConsole.info`Writing TS client to ${resolvedOutPath}`\n  const file = await createAwaitableWriteStream(resolvedOutPath)\n  writeDocumentPartsToStream(parts, file)\n  await file.finish()\n}\n\nasync function createAwaitableWriteStream(path: string) {\n  const fs = await import('fs')\n  const stream = fs.createWriteStream(path, {\n    flags: 'w',\n  })\n  const finish = new Promise<void>((resolve, reject) => {\n    stream.on('error', (err) => {\n      reject(err)\n    })\n    stream.on('finish', () => {\n      resolve()\n    })\n  })\n  return {\n    write(chunk: string): void {\n      stream.write(chunk)\n    },\n    finish() {\n      stream.end()\n      return finish\n    },\n  }\n}\n"],"names":["Command","colorConsole","path","loadApplicationJson","generate","writeDocumentPartsToStream"],"mappings":"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"}

package/cli.mjs

@@ -14,23 +14,12 @@ function cli(workingDirectory, args) {
         .requiredOption('-o --output <path>', 'Specifies the output file path')
         .option('-pn --preserve-names', 'Preserve names from application.json spec instead of sanitizing them')
         .action(async ({ application, output, preserveNames }) => {
-        const fs = await import('fs');
-        const resolvedAppJsonPath = path.resolve(workingDirectory, application);
-        const resolvedOutPath = path.resolve(workingDirectory, output);
-        const resolvedOutDir = path.dirname(resolvedOutPath);
-        colorConsole.info `Reading application.json file from path ${resolvedAppJsonPath}`;
-        const spec = await loadApplicationJson(resolvedAppJsonPath);
-        colorConsole.info `Generating TS client for ${spec.contract.name}`;
-        const parts = generate(spec, { preserveNames: Boolean(preserveNames) });
-        if (!fs.existsSync(resolvedOutDir)) {
-            colorConsole.warn `Output directory ${resolvedOutDir} does not exist and will be created.`;
-            fs.mkdirSync(resolvedOutDir, { recursive: true });
-        }
-        colorConsole.info `Writing TS client to ${resolvedOutPath}`;
-        const file = fs.createWriteStream(resolvedOutPath, {
-            flags: 'w',
+        await generateClientCommand({
+            application,
+            output,
+            preserveNames: Boolean(preserveNames),
+            workingDirectory,
         });
-        writeDocumentPartsToStream(parts, file);
         colorConsole.success `Operation completed successfully`;
     })
         .configureOutput({
@@ -51,6 +40,47 @@ function cli(workingDirectory, args) {
         process.exit(-1);
     }
 }
+async function generateClientCommand({ application, output, preserveNames, workingDirectory, }) {
+    const fs = await import('fs');
+    const resolvedAppJsonPath = path.resolve(workingDirectory, application);
+    const resolvedOutPath = path.resolve(workingDirectory, output);
+    const resolvedOutDir = path.dirname(resolvedOutPath);
+    colorConsole.info `Reading application.json file from path ${resolvedAppJsonPath}`;
+    const spec = await loadApplicationJson(resolvedAppJsonPath);
+    colorConsole.info `Generating TS client for ${spec.name}`;
+    const parts = generate(spec, { preserveNames });
+    if (!fs.existsSync(resolvedOutDir)) {
+        colorConsole.warn `Output directory ${resolvedOutDir} does not exist and will be created.`;
+        fs.mkdirSync(resolvedOutDir, { recursive: true });
+    }
+    colorConsole.info `Writing TS client to ${resolvedOutPath}`;
+    const file = await createAwaitableWriteStream(resolvedOutPath);
+    writeDocumentPartsToStream(parts, file);
+    await file.finish();
+}
+async function createAwaitableWriteStream(path) {
+    const fs = await import('fs');
+    const stream = fs.createWriteStream(path, {
+        flags: 'w',
+    });
+    const finish = new Promise((resolve, reject) => {
+        stream.on('error', (err) => {
+            reject(err);
+        });
+        stream.on('finish', () => {
+            resolve();
+        });
+    });
+    return {
+        write(chunk) {
+            stream.write(chunk);
+        },
+        finish() {
+            stream.end();
+            return finish;
+        },
+    };
+}
 
-export { cli };
+export { cli, generateClientCommand };
 //# sourceMappingURL=cli.mjs.map

package/cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cli.mjs","sources":["../src/cli.ts"],"sourcesContent":["import { Command } from 'commander'\nimport { loadApplicationJson } from './schema/load'\nimport * as path from 'path'\nimport { generate } from './client/generate'\nimport { writeDocumentPartsToStream } from './output/writer'\nimport { colorConsole } from './util/color-console'\n\nexport function cli(workingDirectory: string, args: string[]) {\n  const program = new Command()\n  program\n    .command('generate')\n    .description('Generates a TypeScript client for the given application.json file')\n    .requiredOption('-a --application <path>', 'Specifies the application.json file')\n    .requiredOption('-o --output <path>', 'Specifies the output file path')\n    .option('-pn --preserve-names', 'Preserve names from application.json spec instead of sanitizing them')\n    .action(\n      async ({ application, output, preserveNames }: { application: string; output: string; preserveNames?: boolean }): Promise<void> => {\n        const fs = await import('fs')\n        const resolvedAppJsonPath = path.resolve(workingDirectory, application)\n        const resolvedOutPath = path.resolve(workingDirectory, output)\n        const resolvedOutDir = path.dirname(resolvedOutPath)\n        colorConsole.info`Reading application.json file from path ${resolvedAppJsonPath}`\n        const spec = await loadApplicationJson(resolvedAppJsonPath)\n        colorConsole.info`Generating TS client for ${spec.contract.name}`\n        const parts = generate(spec, { preserveNames: Boolean(preserveNames) })\n        if (!fs.existsSync(resolvedOutDir)) {\n          colorConsole.warn`Output directory ${resolvedOutDir} does not exist and will be created.`\n          fs.mkdirSync(resolvedOutDir, { recursive: true })\n        }\n        colorConsole.info`Writing TS client to ${resolvedOutPath}`\n        const file = fs.createWriteStream(resolvedOutPath, {\n          flags: 'w',\n        })\n        writeDocumentPartsToStream(parts, file)\n        colorConsole.success`Operation completed successfully`\n      },\n    )\n    .configureOutput({\n      writeErr(str: string) {\n        colorConsole.error`${str}`\n      },\n    })\n  try {\n    program.parse(args)\n  } catch (err) {\n    if (err instanceof Error) {\n      colorConsole.error`Unhandled error: \\n\\n${err.stack}`\n    } else {\n      colorConsole.error`Unhandled error: \\n\\n${err}`\n    }\n    process.exit(-1)\n  }\n}\n"],"names":[],"mappings":";;;;;;;AAOgB,SAAA,GAAG,CAAC,gBAAwB,EAAE,IAAc,EAAA;AAC1D,IAAA,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAA;IAC7B,OAAO;SACJ,OAAO,CAAC,UAAU,CAAC;SACnB,WAAW,CAAC,mEAAmE,CAAC;AAChF,SAAA,cAAc,CAAC,yBAAyB,EAAE,qCAAqC,CAAC;AAChF,SAAA,cAAc,CAAC,oBAAoB,EAAE,gCAAgC,CAAC;AACtE,SAAA,MAAM,CAAC,sBAAsB,EAAE,sEAAsE,CAAC;SACtG,MAAM,CACL,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAoE,KAAmB;AAChI,QAAA,MAAM,EAAE,GAAG,MAAM,OAAO,IAAI,CAAC,CAAA;QAC7B,MAAM,mBAAmB,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAA;QACvE,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAA;QAC9D,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;AACpD,QAAA,YAAY,CAAC,IAAI,CAAA,CAA2C,wCAAA,EAAA,mBAAmB,EAAE,CAAA;AACjF,QAAA,MAAM,IAAI,GAAG,MAAM,mBAAmB,CAAC,mBAAmB,CAAC,CAAA;QAC3D,YAAY,CAAC,IAAI,CAAA,CAA4B,yBAAA,EAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE,CAAA;AACjE,QAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;QACvE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;AAClC,YAAA,YAAY,CAAC,IAAI,CAAA,CAAoB,iBAAA,EAAA,cAAc,sCAAsC,CAAA;YACzF,EAAE,CAAC,SAAS,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;SAClD;AACD,QAAA,YAAY,CAAC,IAAI,CAAA,CAAwB,qBAAA,EAAA,eAAe,EAAE,CAAA;AAC1D,QAAA,MAAM,IAAI,GAAG,EAAE,CAAC,iBAAiB,CAAC,eAAe,EAAE;AACjD,YAAA,KAAK,EAAE,GAAG;AACX,SAAA,CAAC,CAAA;AACF,QAAA,0BAA0B,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AACvC,QAAA,YAAY,CAAC,OAAO,CAAA,CAAA,gCAAA,CAAkC,CAAA;AACxD,KAAC,CACF;AACA,SAAA,eAAe,CAAC;AACf,QAAA,QAAQ,CAAC,GAAW,EAAA;AAClB,YAAA,YAAY,CAAC,KAAK,CAAA,CAAG,EAAA,GAAG,EAAE,CAAA;SAC3B;AACF,KAAA,CAAC,CAAA;AACJ,IAAA,IAAI;AACF,QAAA,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;KACpB;IAAC,OAAO,GAAG,EAAE;AACZ,QAAA,IAAI,GAAG,YAAY,KAAK,EAAE;YACxB,YAAY,CAAC,KAAK,CAAA,CAAA,qBAAA,EAAwB,GAAG,CAAC,KAAK,EAAE,CAAA;SACtD;aAAM;AACL,YAAA,YAAY,CAAC,KAAK,CAAA,CAAwB,qBAAA,EAAA,GAAG,EAAE,CAAA;SAChD;AACD,QAAA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;KACjB;AACH;;;;"}
+{"version":3,"file":"cli.mjs","sources":["../src/cli.ts"],"sourcesContent":["import { Command } from 'commander'\nimport { loadApplicationJson } from './schema/load'\nimport * as path from 'path'\nimport { generate } from './client/generate'\nimport { writeDocumentPartsToStream } from './output/writer'\nimport { colorConsole } from './util/color-console'\n\nexport function cli(workingDirectory: string, args: string[]) {\n  const program = new Command()\n  program\n    .command('generate')\n    .description('Generates a TypeScript client for the given application.json file')\n    .requiredOption('-a --application <path>', 'Specifies the application.json file')\n    .requiredOption('-o --output <path>', 'Specifies the output file path')\n    .option('-pn --preserve-names', 'Preserve names from application.json spec instead of sanitizing them')\n    .action(\n      async ({ application, output, preserveNames }: { application: string; output: string; preserveNames?: boolean }): Promise<void> => {\n        await generateClientCommand({\n          application,\n          output,\n          preserveNames: Boolean(preserveNames),\n          workingDirectory,\n        })\n        colorConsole.success`Operation completed successfully`\n      },\n    )\n    .configureOutput({\n      writeErr(str: string) {\n        colorConsole.error`${str}`\n      },\n    })\n  try {\n    program.parse(args)\n  } catch (err) {\n    if (err instanceof Error) {\n      colorConsole.error`Unhandled error: \\n\\n${err.stack}`\n    } else {\n      colorConsole.error`Unhandled error: \\n\\n${err}`\n    }\n    process.exit(-1)\n  }\n}\n\nexport async function generateClientCommand({\n  application,\n  output,\n  preserveNames,\n  workingDirectory,\n}: {\n  application: string\n  output: string\n  preserveNames: boolean\n  workingDirectory: string\n}) {\n  const fs = await import('fs')\n\n  const resolvedAppJsonPath = path.resolve(workingDirectory, application)\n  const resolvedOutPath = path.resolve(workingDirectory, output)\n  const resolvedOutDir = path.dirname(resolvedOutPath)\n  colorConsole.info`Reading application.json file from path ${resolvedAppJsonPath}`\n  const spec = await loadApplicationJson(resolvedAppJsonPath)\n  colorConsole.info`Generating TS client for ${spec.name}`\n  const parts = generate(spec, { preserveNames })\n  if (!fs.existsSync(resolvedOutDir)) {\n    colorConsole.warn`Output directory ${resolvedOutDir} does not exist and will be created.`\n    fs.mkdirSync(resolvedOutDir, { recursive: true })\n  }\n  colorConsole.info`Writing TS client to ${resolvedOutPath}`\n  const file = await createAwaitableWriteStream(resolvedOutPath)\n  writeDocumentPartsToStream(parts, file)\n  await file.finish()\n}\n\nasync function createAwaitableWriteStream(path: string) {\n  const fs = await import('fs')\n  const stream = fs.createWriteStream(path, {\n    flags: 'w',\n  })\n  const finish = new Promise<void>((resolve, reject) => {\n    stream.on('error', (err) => {\n      reject(err)\n    })\n    stream.on('finish', () => {\n      resolve()\n    })\n  })\n  return {\n    write(chunk: string): void {\n      stream.write(chunk)\n    },\n    finish() {\n      stream.end()\n      return finish\n    },\n  }\n}\n"],"names":[],"mappings":"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"}

package/client/{call-factory.d.ts → app-client.d.ts}

@@ -1,3 +1,3 @@
 import { DocumentParts } from '../output/writer';
 import { GeneratorContext } from './generator-context';
-export declare function callFactory(ctx: GeneratorContext): DocumentParts;
+export declare function appClient(ctx: GeneratorContext): DocumentParts;

package/client/app-client.js

@@ -0,0 +1,345 @@
+'use strict';
+
+var writer = require('../output/writer.js');
+var getCallConfigSummary = require('./helpers/get-call-config-summary.js');
+var deployTypes = require('./deploy-types.js');
+var callComposer = require('./call-composer.js');
+var algosdk = require('algosdk');
+var getEquivalentType = require('./helpers/get-equivalent-type.js');
+
+function* appClient(ctx) {
+    const { app, name } = ctx;
+    yield* writer.jsDoc(`A client to make calls to the ${app.name} smart contract`);
+    yield `export class ${name}Client {`;
+    yield writer.IncIndent;
+    yield* writer.jsDoc(`The underlying \`AppClient\` for when you want to have more flexibility`);
+    yield 'public readonly appClient: AppClient';
+    yield writer.NewLine;
+    yield `
+    /**
+     * Creates a new instance of \`${name}Client\`
+     *
+     * @param appClient An \`AppClient\` instance which has been created with the ${name} app spec
+     */
+    constructor(appClient: AppClient)
+    /**
+     * Creates a new instance of \`${name}Client\`
+     *
+     * @param params The parameters to initialise the app client with
+     */
+    constructor(params: Omit<AppClientParams, 'appSpec'>)
+    constructor(appClientOrParams: AppClient | Omit<AppClientParams, 'appSpec'>) {
+      this.appClient = appClientOrParams instanceof AppClient ? appClientOrParams : new AppClient({
+        ...appClientOrParams,
+        appSpec: APP_SPEC,
+      })
+    }
+
+    /**
+     * Checks for decode errors on the given return value and maps the return value to the return type for the given method
+     * @returns The typed return value or undefined if there was no value
+     */
+    decodeReturnValue<TSignature extends ${name}NonVoidMethodSignatures>(method: TSignature, returnValue: ABIReturn | undefined) {
+      return returnValue !== undefined ? getArc56ReturnValue<MethodReturn<TSignature>>(returnValue, this.appClient.getABIMethod(method), APP_SPEC.structs) : undefined
+    }
+
+    /**
+     * Returns a new \`${name}Client\` client, resolving the app by creator address and name
+     * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
+     * @param params The parameters to create the app client
+     */
+    public static async fromCreatorAndName(params: Omit<ResolveAppClientByCreatorAndName, 'appSpec'>): Promise<${name}Client> {
+      return new ${name}Client(await AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC}))
+    }
+
+    /**
+     * Returns an \`${name}Client\` instance for the current network based on
+     * pre-determined network-specific app IDs specified in the ARC-56 app spec.
+     *
+     * If no IDs are in the app spec or the network isn't recognised, an error is thrown.
+     * @param params The parameters to create the app client
+     */
+    static async fromNetwork(
+      params: Omit<ResolveAppClientByNetwork, 'appSpec'>
+    ): Promise<${name}Client> {
+      return new ${name}Client(await AppClient.fromNetwork({...params, appSpec: APP_SPEC}))
+    }
+
+    /** The ID of the app instance this client is linked to. */
+    public get appId() {
+      return this.appClient.appId
+    }
+
+    /** The app address of the app instance this client is linked to. */
+    public get appAddress() {
+      return this.appClient.appAddress
+    }
+
+    /** The name of the app. */
+    public get appName() {
+      return this.appClient.appName
+    }
+
+    /** The ARC-56 app spec being used */
+    public get appSpec() {
+      return this.appClient.appSpec
+    }
+
+    /** A reference to the underlying \`AlgorandClient\` this app client is using. */
+    public get algorand(): AlgorandClientInterface {
+      return this.appClient.algorand
+    }
+
+  `;
+    yield* params(ctx);
+    yield* createTransaction(ctx);
+    yield* send(ctx);
+    yield* cloneMethod(ctx);
+    yield* readonlyMethods(ctx);
+    yield* getStateMethods(ctx);
+    yield* callComposer.composeMethod(ctx);
+    yield writer.DecIndentAndCloseBlock;
+}
+function* params(ctx) {
+    yield* writer.jsDoc(`Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation.`);
+    yield `readonly params = {`;
+    yield writer.IncIndent;
+    yield* opMethods(ctx, 'params');
+    yield* clearState(ctx, 'params');
+    yield* call(ctx, 'params');
+    yield* noopMethods(ctx, 'params');
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.NewLine;
+}
+function* createTransaction(ctx) {
+    yield* writer.jsDoc(`Create transactions for the current app`);
+    yield `readonly createTransaction = {`;
+    yield writer.IncIndent;
+    yield* opMethods(ctx, 'createTransaction');
+    yield* clearState(ctx, 'createTransaction');
+    yield* call(ctx, 'createTransaction');
+    yield* noopMethods(ctx, 'createTransaction');
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.NewLine;
+}
+function* send(ctx) {
+    yield* writer.jsDoc(`Send calls to the current app`);
+    yield `readonly send = {`;
+    yield writer.IncIndent;
+    yield* opMethods(ctx, 'send');
+    yield* clearState(ctx, 'send');
+    yield* call(ctx, 'send');
+    yield* noopMethods(ctx, 'send');
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.NewLine;
+}
+function* opMethods(ctx, type) {
+    const { app, callConfig } = ctx;
+    yield* operationMethods(ctx, `Updates an existing instance of the ${app.name} smart contract`, callConfig.updateMethods, 'update', type, true);
+    yield* operationMethods(ctx, `Deletes an existing instance of the ${app.name} smart contract`, callConfig.deleteMethods, 'delete', type);
+    yield* operationMethods(ctx, `Opts the user into an existing instance of the ${app.name} smart contract`, callConfig.optInMethods, 'optIn', type);
+    yield* operationMethods(ctx, `Makes a close out call to an existing instance of the ${app.name} smart contract`, callConfig.closeOutMethods, 'closeOut', type);
+}
+function* bareMethodCall({ generator: { app }, name, description, verb, type, includeCompilation, }) {
+    const onComplete = verb === 'create' ? deployTypes.getCreateOnCompleteOptions(getCallConfigSummary.BARE_CALL, app) : verb === 'call' ? deployTypes.getCallOnCompleteOptions(getCallConfigSummary.BARE_CALL, app) : undefined;
+    yield* writer.jsDoc({
+        description: `${description}.`,
+        params: {
+            params: `The params for the bare (raw) call`,
+        },
+        returns: `The ${verb} result`,
+    });
+    yield `${name}: (params?: Expand<AppClientBareCallParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${verb === 'create' ? ' & CreateSchema' : ''}${type === 'send' ? ' & SendParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}>) => {`;
+    yield* writer.indent(`return this.appClient.${type}.bare.${verb}(params)`);
+    yield '},';
+}
+function* abiMethodCall({ generator: { app, methodSignatureToUniqueName, name, sanitizer }, method, description, verb, type, includeCompilation, readonly, }) {
+    const methodSig = new algosdk.ABIMethod(method).getSignature();
+    const uniqueName = methodSignatureToUniqueName[methodSig];
+    const onComplete = verb === 'create'
+        ? deployTypes.getCreateOnCompleteOptions(methodSig, app)
+        : verb === 'call' && !readonly
+            ? deployTypes.getCallOnCompleteOptions(methodSig, app)
+            : undefined;
+    yield* writer.jsDoc({
+        description: verb === 'call' && method.readonly
+            ? [
+                `${description} using the \`${methodSig}\` ABI method.`,
+                '',
+                'This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.',
+            ]
+            : `${description} using the \`${methodSig}\` ABI method.`,
+        abiDescription: method?.desc,
+        params: {
+            params: `The params for the smart contract call`,
+        },
+        returns: `The ${verb} ${type === 'params' ? 'params' : type === 'createTransaction' ? 'transaction' : 'result'}${method?.returns?.desc ? `: ${method.returns.desc}` : ''}`,
+    });
+    const methodName = sanitizer.makeSafeMethodIdentifier(uniqueName);
+    const methodNameAccessor = sanitizer.getSafeMemberAccessor(methodName);
+    const methodSigSafe = sanitizer.makeSafeStringTypeLiteral(methodSig);
+    yield `${!readonly ? `${methodName}: ` : ''}${type === 'send' ? 'async ' : ''}${readonly ? `${methodName}` : ''}(params: CallParams<${name}Args['obj']['${methodSigSafe}'] | ${name}Args['tuple']['${methodSigSafe}']>${includeCompilation ? ' &' + ' AppClientCompilationParams' : ''}${verb === 'create' ? ' & CreateSchema' : ''}${type === 'send' && !readonly ? ' & SendParams' : ''}${onComplete?.type && !readonly ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false && (method.args.length === 0 || !method.args.some((a) => !a.defaultValue)) ? ` = {args: [${method.args.map((_) => 'undefined').join(', ')}]}` : ''})${!readonly ? ' =>' : ''} {`;
+    if (type === 'send') {
+        yield* writer.indent(`const result = await this.appClient.${type}.${verb}(${name}ParamsFactory${verb !== 'call' ? `.${verb}` : ''}${methodNameAccessor}(params))`, readonly
+            ? `return result.return as ${name}Returns['${methodSigSafe}']`
+            : `return {...result, return: result.return as undefined | ${name}Returns['${methodSigSafe}']}`);
+    }
+    else {
+        yield* writer.indent(`return this.appClient.${type}.${verb}(${name}ParamsFactory${verb !== 'call' ? `.${verb}` : ''}${methodNameAccessor}(params))`);
+    }
+    yield `}${!readonly ? ',' : ''}`;
+    yield writer.NewLine;
+}
+function* operationMethods(generator, description, methods, verb, type, includeCompilation) {
+    if (methods.length) {
+        yield* writer.jsDoc(`Gets available ${verb} methods`);
+        yield `${verb}: {`;
+        yield writer.IncIndent;
+        for (const methodSig of methods) {
+            if (methodSig === getCallConfigSummary.BARE_CALL) {
+                yield* bareMethodCall({
+                    generator,
+                    name: 'bare',
+                    description: `${description} using a bare call`,
+                    verb,
+                    type,
+                    includeCompilation,
+                });
+            }
+            else {
+                const method = generator.app.methods.find((m) => new algosdk.ABIMethod(m).getSignature() === methodSig);
+                yield* abiMethodCall({
+                    generator,
+                    method,
+                    description,
+                    verb,
+                    type,
+                    includeCompilation,
+                });
+            }
+        }
+        yield writer.DecIndent;
+        yield '},';
+        yield writer.NewLine;
+    }
+}
+function* clearState(generator, type) {
+    yield* bareMethodCall({
+        generator,
+        name: 'clearState',
+        description: `Makes a clear_state call to an existing instance of the ${generator.app.name} smart contract`,
+        verb: 'clearState',
+        type,
+    });
+    yield writer.NewLine;
+}
+function* call(generator, type) {
+    if (generator.callConfig.callMethods.includes(getCallConfigSummary.BARE_CALL)) {
+        yield* bareMethodCall({
+            generator,
+            name: 'bare',
+            description: `Makes a call to the ${generator.app.name} smart contract using a bare call`,
+            verb: 'call',
+            type,
+        });
+        yield writer.NewLine;
+    }
+}
+function* readonlyMethods(generator) {
+    const { app, callConfig } = generator;
+    for (const method of app.methods) {
+        const methodSignature = new algosdk.ABIMethod(method).getSignature();
+        // Skip non readonly methods
+        if (!callConfig.callMethods.includes(methodSignature) || !method.readonly)
+            continue;
+        yield* abiMethodCall({
+            generator,
+            description: `Makes a readonly (simulated) call to the ${generator.app.name} smart contract`,
+            method,
+            verb: 'call',
+            type: 'send',
+            includeCompilation: false,
+            readonly: true,
+        });
+    }
+}
+function* noopMethods(generator, type) {
+    const { app, callConfig } = generator;
+    for (const method of app.methods) {
+        const methodSignature = new algosdk.ABIMethod(method).getSignature();
+        // Skip methods which don't support a no_op call config
+        if (!callConfig.callMethods.includes(methodSignature))
+            continue;
+        yield* abiMethodCall({
+            generator,
+            description: `Makes a call to the ${generator.app.name} smart contract`,
+            method,
+            verb: 'call',
+            type,
+            includeCompilation: false,
+        });
+    }
+}
+function* getStateMethods({ app, sanitizer }) {
+    if (Object.keys(app.state).length === 0)
+        return;
+    yield* writer.jsDoc(`Methods to access state for the current ${app.name} app`);
+    yield 'state = {';
+    yield writer.IncIndent;
+    const storageTypes = ['global', 'local', 'box'];
+    for (const storageType of storageTypes) {
+        const hasKeys = Object.keys(app.state.keys[storageType]).length > 0;
+        const hasMaps = Object.keys(app.state.maps[storageType]).length > 0;
+        if (!hasKeys && !hasMaps)
+            continue;
+        yield* writer.jsDoc(`Methods to access ${storageType} state for the current ${app.name} app`);
+        yield `${storageType}${storageType === 'local' ? ': (address: string | Address) => ({' : ': {'}`;
+        yield writer.IncIndent;
+        yield* writer.jsDoc(`Get all current keyed values from ${storageType} state`);
+        yield `getAll: async (): Promise<Partial<Expand<${storageType[0].toUpperCase()}${storageType.substring(1)}KeysState>>> => {`;
+        yield* writer.indent(`const result = await this.appClient.state.${storageType}${storageType === 'local' ? '(address)' : ''}.getAll()`, `return {`, ...Object.keys(app.state.keys[storageType]).map((n) => {
+            return `  ${sanitizer.makeSafePropertyIdentifier(n)}: ${app.state.keys[storageType][n].valueType === 'AVMBytes' ? `new BinaryStateValue(result${sanitizer.getSafeMemberAccessor(n)})` : `result${sanitizer.getSafeMemberAccessor(n)}`},`;
+        }), `}`);
+        yield `},`;
+        for (const n of Object.keys(app.state.keys[storageType])) {
+            const name = sanitizer.makeSafePropertyIdentifier(n);
+            const k = app.state.keys[storageType][n];
+            yield* writer.jsDoc(`Get the current value of the ${n} key in ${storageType} state`);
+            yield `${name}: async (): Promise<${k.valueType === 'AVMBytes' ? 'BinaryState' : `${getEquivalentType.getEquivalentType(k.valueType, 'output', { app, sanitizer })} | undefined`}> => { return ${k.valueType === 'AVMBytes' ? 'new BinaryStateValue(' : ''}(await this.appClient.state.${storageType}${storageType === 'local' ? '(address)' : ''}.getValue("${name}"))${k.valueType === 'AVMBytes' ? ' as Uint8Array | undefined)' : ` as ${getEquivalentType.getEquivalentType(k.valueType, 'output', { app, sanitizer })} | undefined`} },`;
+        }
+        for (const n of Object.keys(app.state.maps[storageType])) {
+            const name = sanitizer.makeSafePropertyIdentifier(app.state.keys[storageType][n] ? `${n}Map` : n);
+            const m = app.state.maps[storageType][n];
+            yield* writer.jsDoc(`Get values from the ${n} map in ${storageType} state`);
+            yield `${name}: {`;
+            yield writer.IncIndent;
+            yield* writer.jsDoc(`Get all current values of the ${n} map in ${storageType} state`);
+            yield `getMap: async (): Promise<Map<${getEquivalentType.getEquivalentType(m.keyType, 'output', { app, sanitizer })}, ${getEquivalentType.getEquivalentType(m.valueType, 'output', { app, sanitizer })}>> => { return (await this.appClient.state.${storageType}${storageType === 'local' ? '(address)' : ''}.getMap("${sanitizer.makeSafeStringTypeLiteral(n)}")) as Map<${getEquivalentType.getEquivalentType(m.keyType, 'output', { app, sanitizer })}, ${getEquivalentType.getEquivalentType(m.valueType, 'output', { app, sanitizer })}> },`;
+            yield* writer.jsDoc(`Get a current value of the ${n} map by key from ${storageType} state`);
+            yield `value: async (key: ${getEquivalentType.getEquivalentType(m.keyType, 'input', { app, sanitizer })}): Promise<${getEquivalentType.getEquivalentType(m.valueType, 'output', { app, sanitizer })} | undefined> => { return await this.appClient.state.${storageType}${storageType === 'local' ? '(address)' : ''}.getMapValue("${sanitizer.makeSafeStringTypeLiteral(n)}", key) as ${getEquivalentType.getEquivalentType(m.valueType, 'output', { app, sanitizer })} | undefined },`;
+            yield writer.DecIndent;
+            yield `},`;
+        }
+        yield writer.DecIndent;
+        yield `}${storageType === 'local' ? ')' : ''},`;
+    }
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.NewLine;
+}
+function* cloneMethod({ name }) {
+    yield* writer.jsDoc({
+        description: 'Clone this app client with different params',
+        params: {
+            params: 'The params to use for the the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value.',
+        },
+        returns: 'A new app client with the altered params',
+    });
+    yield `public clone(params: CloneAppClientParams) {`;
+    yield writer.IncIndent;
+    yield `return new ${name}Client(this.appClient.clone(params))`;
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.NewLine;
+}
+
+exports.appClient = appClient;
+//# sourceMappingURL=app-client.js.map