@taqueria/plugin-contract-types 0.3.1 → 0.4.0-rc3

package/src/type-utils.ts

@@ -1,35 +1,33 @@
 import { ContractAbstraction, ContractMethod, ContractMethodObject, ContractProvider, Wallet } from '@taquito/taquito';
 
-type BaseContractType = { methods: unknown, methodsObject: unknown, storage: unknown };
+type BaseContractType = { methods: unknown; methodsObject: unknown; storage: unknown };
 
 type ContractMethodsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
-[M in keyof TContract['methods']]:
-TContract['methods'][M] extends (...args: infer A) => unknown
-? (...args: A) => ContractMethod<T>
-: never
+	[M in keyof TContract['methods']]: TContract['methods'][M] extends (...args: infer A) => unknown
+		? (...args: A) => ContractMethod<T>
+		: never;
 };
 type ContractMethodsObjectsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
-[M in keyof TContract['methodsObject']]:
-TContract['methodsObject'][M] extends (...args: infer A) => unknown
-? (...args: A) => ContractMethodObject<T>
-: never
+	[M in keyof TContract['methodsObject']]: TContract['methodsObject'][M] extends (...args: infer A) => unknown
+		? (...args: A) => ContractMethodObject<T>
+		: never;
 };
 type ContractStorageOf<TContract extends BaseContractType> = TContract['storage'];
 
-export type ContractAbstractionFromContractType<TContract extends BaseContractType> = 
-    ContractAbstraction<ContractProvider, 
-        ContractMethodsOf<ContractProvider, TContract>,
-        ContractMethodsObjectsOf<ContractProvider, TContract>,
-        {},
-        {},
-        ContractStorageOf<TContract>
-    >;
+export type ContractAbstractionFromContractType<TContract extends BaseContractType> = ContractAbstraction<
+	ContractProvider,
+	ContractMethodsOf<ContractProvider, TContract>,
+	ContractMethodsObjectsOf<ContractProvider, TContract>,
+	{},
+	{},
+	ContractStorageOf<TContract>
+>;
 
-export type WalletContractAbstractionFromContractType<TContract extends BaseContractType> = 
-    ContractAbstraction<Wallet, 
-        ContractMethodsOf<Wallet, TContract>,
-        ContractMethodsObjectsOf<Wallet, TContract>,
-        {},
-        {},
-        ContractStorageOf<TContract>
-    >;
+export type WalletContractAbstractionFromContractType<TContract extends BaseContractType> = ContractAbstraction<
+	Wallet,
+	ContractMethodsOf<Wallet, TContract>,
+	ContractMethodsObjectsOf<Wallet, TContract>,
+	{},
+	{},
+	ContractStorageOf<TContract>
+>;

package/tasks.ts

@@ -1,59 +1,56 @@
-import { SanitizedArgs, PluginResponse, Failure, LikeAPromise } from "@taqueria/node-sdk/types";
-import glob from 'fast-glob'
-import { join } from 'path'
-import { generateContractTypesProcessContractFiles } from "./src/cli-process";
-
-type PluginOpts = {
-    // TODO: Document these
-    typescriptDir: string,
-    typeAliasMode?: 'local' | 'file' | 'library' | 'simple',
-};
-type Opts = SanitizedArgs & Record<string, unknown>;
-
-const getContractAbspath = (contractFilename: string, parsedArgs: Opts) => 
-    join(parsedArgs.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`)
-
-
-const generateContractTypes = (parsedArgs: Opts & PluginOpts) => async (contractFilename: string) : Promise<string> => {
-    const contractAbspath = getContractAbspath(contractFilename, parsedArgs);
-    await generateContractTypesProcessContractFiles({
-        inputTzContractDirectory: parsedArgs.artifactsDir,
-        inputFiles: [contractAbspath],
-        outputTypescriptDirectory: parsedArgs.typescriptDir,
-        format: 'tz',
-        typeAliasMode: parsedArgs.typeAliasMode ?? 'file',
-    });
-
-    return `${contractFilename}: Types generated`;
+import { LikeAPromise, PluginResponse, RequestArgs, TaqError } from '@taqueria/node-sdk/types';
+import glob from 'fast-glob';
+import { join } from 'path';
+import { generateContractTypesProcessContractFiles } from './src/cli-process';
+interface Opts extends RequestArgs.ProxyRequestArgs {
+	// TODO: Document these
+	typescriptDir?: string;
+	typeAliasMode?: 'local' | 'file' | 'library' | 'simple';
+	contract?: string;
 }
 
-const generateContractTypesAll = async (parsedArgs: Opts & PluginOpts) : Promise<string[]> => {
-    const files = await glob("**/*.tz", {cwd: parsedArgs.artifactsDir});
-    return await Promise.all(files.map(generateContractTypes(parsedArgs)));
-}
-
-export const generateTypes = <T>(parsedArgs: Opts): LikeAPromise<PluginResponse, Failure<T>> => {
-    parsedArgs.typescriptDir = parsedArgs.typescriptDir || 'types';
+const getContractAbspath = (contractFilename: string, parsedArgs: Opts) =>
+	join(parsedArgs.config.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`);
+
+const generateContractTypes = (parsedArgs: Opts) =>
+	async (contractFilename: string): Promise<string> => {
+		const contractAbspath = getContractAbspath(contractFilename, parsedArgs);
+		await generateContractTypesProcessContractFiles({
+			inputTzContractDirectory: parsedArgs.config.artifactsDir,
+			inputFiles: [contractAbspath],
+			outputTypescriptDirectory: parsedArgs.typescriptDir || 'types',
+			format: 'tz',
+			typeAliasMode: parsedArgs.typeAliasMode ?? 'file',
+		});
+
+		return `${contractFilename}: Types generated`;
+	};
+
+const generateContractTypesAll = async (parsedArgs: Opts): Promise<string[]> => {
+	const files = await glob('**/*.tz', { cwd: parsedArgs.config.artifactsDir });
+	return await Promise.all(files.map(generateContractTypes(parsedArgs)));
+};
 
-    console.log('generateTypes', { 
-        typescriptDir: parsedArgs.typescriptDir
-    });
+export const generateTypes = (parsedArgs: Opts): LikeAPromise<PluginResponse, TaqError.t> => {
+	parsedArgs.typescriptDir = parsedArgs.typescriptDir || 'types';
 
-    const argsTyped = parsedArgs as Opts & PluginOpts;
+	console.log('generateTypes', {
+		typescriptDir: parsedArgs.typescriptDir,
+	});
 
-    const p = argsTyped.contract
-        ? generateContractTypes(argsTyped) (argsTyped.contract as string)
-        : generateContractTypesAll(argsTyped)
+	const p = parsedArgs.contract
+		? generateContractTypes(parsedArgs)(parsedArgs.contract)
+		: generateContractTypesAll(parsedArgs);
 
-    return p.then(data => {
-        console.log(
-            (Array.isArray(data))
-            ? data.join("\n")
-            : data
-        )
-    })
-}
+	return p.then(data => {
+		console.log(
+			(Array.isArray(data))
+				? data.join('\n')
+				: data,
+		);
+	});
+};
 
 export const tasks = {
-    generateTypes,
-} 
+	generateTypes,
+};

package/test/generator.spec.ts

@@ -1,70 +1,79 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import { promisify } from 'util';
-import { generateContractTypesFromMichelsonCode } from '../src/generator/process';
 import { normalizeContractName } from '../src/generator/contract-name';
+import { generateContractTypesFromMichelsonCode } from '../src/generator/process';
 import { TypeAliasData, TypeUtilsData } from '../src/generator/typescript-output';
 
-
 const readFileText = async (filePath: string): Promise<string> => {
-    return fs.readFile(filePath, { encoding: 'utf8' });
+	return fs.readFile(filePath, { encoding: 'utf8' });
 };
 
 describe('Generate Example Contracts', () => {
+	const typeAliasDataLibrary: TypeAliasData = { mode: 'library', importPath: '@taquito/contract-type-generator' };
+	const typeAliasDataSimple: TypeAliasData = { mode: 'simple' };
 
-    const typeAliasDataLibrary: TypeAliasData = { mode: 'library', importPath: '@taquito/contract-type-generator' };
-    const typeAliasDataSimple: TypeAliasData = { mode: 'simple' };
-
-    const exampleDir = path.resolve(__dirname, `../example`);
-
-    const testContractTypeGeneration = async (contractFileName: string, format: 'tz' | 'json', mode: 'library' | 'simple') => {
-        const contractRaw = await readFileText(`${exampleDir}/contracts/${contractFileName}.${format}`);
-        const expectedTypeFileContent = await readFileText(`${exampleDir}/types${mode === 'simple' ? '-simple' : ''}/${contractFileName}.types.ts`);
-        const expectedCodeFileContent = await readFileText(`${exampleDir}/types${mode === 'simple' ? '-simple' : ''}/${contractFileName}.code.ts`);
-        const contractName = normalizeContractName(contractFileName);
-        const typeAliasData = mode === 'library' ? typeAliasDataLibrary : typeAliasDataSimple;
-        const typeUtilsData: TypeUtilsData = { importPath: `./type-utils` };
-        const { typescriptCodeOutput: { typesFileContent: actualTypesFileContent, contractCodeFileContent: actualCodeFileContent } } = generateContractTypesFromMichelsonCode(contractRaw, contractName, format, typeAliasData, typeUtilsData);
-        expect(actualTypesFileContent.trim()).toEqual(expectedTypeFileContent.trim());
-        expect(actualCodeFileContent.trim()).toEqual(expectedCodeFileContent.trim());
-    };
-
-    it('Generate Types 01 - tz library', async () => {
-        await testContractTypeGeneration('example-contract-1', 'tz', 'library');
-    });
-    it('Generate Types 01 - tz simple', async () => {
-        await testContractTypeGeneration('example-contract-1', 'tz', 'simple');
-    });
-    it('Generate Types 02 - tz library', async () => {
-        await testContractTypeGeneration('example-contract-2', 'tz', 'library');
-    });
-    it('Generate Types 02 - tz simple', async () => {
-        await testContractTypeGeneration('example-contract-2', 'tz', 'simple');
-    });
+	const exampleDir = path.resolve(__dirname, `../example`);
 
-    it('Generate Types 03 - json library', async () => {
-        await testContractTypeGeneration('example-contract-3', 'json', 'library');
-    });
+	const testContractTypeGeneration = async (
+		contractFileName: string,
+		format: 'tz' | 'json',
+		mode: 'library' | 'simple',
+	) => {
+		const contractRaw = await readFileText(`${exampleDir}/contracts/${contractFileName}.${format}`);
+		const expectedTypeFileContent = await readFileText(
+			`${exampleDir}/types${mode === 'simple' ? '-simple' : ''}/${contractFileName}.types.ts`,
+		);
+		const expectedCodeFileContent = await readFileText(
+			`${exampleDir}/types${mode === 'simple' ? '-simple' : ''}/${contractFileName}.code.ts`,
+		);
+		const contractName = normalizeContractName(contractFileName);
+		const typeAliasData = mode === 'library' ? typeAliasDataLibrary : typeAliasDataSimple;
+		const typeUtilsData: TypeUtilsData = { importPath: `./type-utils` };
+		const {
+			typescriptCodeOutput: {
+				typesFileContent: actualTypesFileContent,
+				contractCodeFileContent: actualCodeFileContent,
+			},
+		} = generateContractTypesFromMichelsonCode(contractRaw, contractName, format, typeAliasData, typeUtilsData);
+		expect(actualTypesFileContent.trim()).toEqual(expectedTypeFileContent.trim());
+		expect(actualCodeFileContent.trim()).toEqual(expectedCodeFileContent.trim());
+	};
 
-    it('Generate Types 04 - newer protocol', async () => {
-        await testContractTypeGeneration('example-contract-4', 'tz', 'library');
-    });
-    it('Generate Types 04 - tz simple', async () => {
-        await testContractTypeGeneration('example-contract-4', 'tz', 'simple');
-    });
+	it('Generate Types 01 - tz library', async () => {
+		await testContractTypeGeneration('example-contract-1', 'tz', 'library');
+	});
+	it('Generate Types 01 - tz simple', async () => {
+		await testContractTypeGeneration('example-contract-1', 'tz', 'simple');
+	});
+	it('Generate Types 02 - tz library', async () => {
+		await testContractTypeGeneration('example-contract-2', 'tz', 'library');
+	});
+	it('Generate Types 02 - tz simple', async () => {
+		await testContractTypeGeneration('example-contract-2', 'tz', 'simple');
+	});
 
-    // it(`Generate Types - All`, async () => {
-    //     const allExampleContracts = (await fs.readdir(`${exampleDir}/contracts/`)).filter(f=>f.endsWith('.tz') || f.endsWith('.json'));
+	it('Generate Types 03 - json library', async () => {
+		await testContractTypeGeneration('example-contract-3', 'json', 'library');
+	});
 
-    //     for(const f of allExampleContracts){
-    //         const fRelative = f.replace(exampleDir,'');
-    //         const m = fRelative.match(/^(.*)\.(tz|json)$/);
-    //         if(!m){ return; }
-    //         const [_,filename, ext] = m;
+	it('Generate Types 04 - newer protocol', async () => {
+		await testContractTypeGeneration('example-contract-4', 'tz', 'library');
+	});
+	it('Generate Types 04 - tz simple', async () => {
+		await testContractTypeGeneration('example-contract-4', 'tz', 'simple');
+	});
 
-    //         await testContractTypeGeneration(filename, ext as 'tz'|'json', 'simple');
-    //     }
-    // });
+	// it(`Generate Types - All`, async () => {
+	//     const allExampleContracts = (await fs.readdir(`${exampleDir}/contracts/`)).filter(f=>f.endsWith('.tz') || f.endsWith('.json'));
 
+	//     for(const f of allExampleContracts){
+	//         const fRelative = f.replace(exampleDir,'');
+	//         const m = fRelative.match(/^(.*)\.(tz|json)$/);
+	//         if(!m){ return; }
+	//         const [_,filename, ext] = m;
 
+	//         await testContractTypeGeneration(filename, ext as 'tz'|'json', 'simple');
+	//     }
+	// });
 });

package/tsconfig.json

@@ -1,13 +1,13 @@
 {
-  "compilerOptions": {
-    "target": "ES2021",
-    "module": "CommonJS",
-    "declaration": true,
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "lib",
-  }
-}
+	"compilerOptions": {
+		"target": "ES2021",
+		"module": "CommonJS",
+		"declaration": true,
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"strict": true,
+		"skipLibCheck": true,
+		"outDir": "lib"
+	}
+}

package/Readme.md

@@ -1,259 +0,0 @@
-This plugin provides a `taq generate types` command which will generate and export TypeScript types from compiled Michelson smart contracts. These generated types then work with your IDE and Taquito, providing type safety and an improved code authoring experience
-
-Benefits of using generated types:
-- Static types used to call smart contract methods are checked at compile time, improving code reliability
-- Generated types enable auto-completion and syntax highlighting in your IDE
-- Developing apps with Taquito is faster and more reliable
-- The VS Code Extension provides tooltip hints for parameter types used to call a smart contract method
-- Calling smart contract methods with types is done directly, removing the need for utility methods 
-- Simplifies your code and improves readability
-
-## Requirements
-
-- Node JS v16 or later
-- Taquito v11.2 or later (optional)
-
-## Installation
-
-To install the Contract Types plugin on a Taqueria project, navigate to the project folder and run:
-```shell
-taq install @taqueria/plugin-contract-types
-```
-
-## Configuration
-
-This plugin will look for Michelson files according to the `artifactsDir` configured in `./.taq/config.json`. By default, this value is `/artifacts` but can be changed as needed
-
-## Usage
-
-The plugin provides a single command to Taqueria: `taq generate types`
-
-This will look for `.tz` files in the `/artifacts` directory and will generate a series of related `.ts` files in the `/types` directory. These files export type definitions for each method which can then be used by Taquito and your IDE
-
-### The `generate types` Command
-
-#### Syntax
-```shell
-taq generate types [typeOutputDir]
-```
-
-#### Parameters
-
-| parameter     |  required  | description                                        |       
-|:-------------:|:-----------|----------------------------------------------------|
-| typeOutputDir | no         | The output directory for the `.ts` files generated |
-
-#### CLI Aliases
-
-The following aliases are interchangable with `generate types`
-- `gen`
-- `gentypes`
-
-#### Options
-
-The `generate types` command will accept the following optional parameters:
-
-| flag  |  name         | description                                  |       
-|:-----:|:--------------|----------------------------------------------|
-|  -t   | typeAliasMode | Use type aliases in the generated types      |
- 
-## Examples
-
-### Example Usage (based on an nft auction contract from open minter sdk)
-
-```ts
-export const exampleContractMethods1 = async () => {
-
-    const Tezos = new TezosToolkit(`https://YOUR_PREFERRED_RPC_URL`)
-
-    const contract = await Tezos.contract.at<TestContract>(`tz123`);
-
-    contract.methods.bid(tas.nat(0));
-    contract.methods.configure(
-        /*opening_price:*/ tas.mutez(10),
-        /*min_raise_percent:*/ tas.nat(10),
-        /*min_raise:*/ tas.mutez(10),
-        /*round_time:*/ tas.nat(10),
-        /*extend_time:*/ tas.nat(10),
-        /*asset:*/ [{
-            fa2_address: tas.address(`tz123`),
-            fa2_batch: [{
-                amount: tas.nat(100),
-                token_id: tas.nat(`100000000000000`),
-            }],
-        }],
-        /*start_time:*/ tas.timestamp(new Date()),
-        /*end_time:*/ tas.timestamp(`2020-01-01`),
-    );
-
-    // methodsObject
-    contract.methodsObject.bid(tas.nat(0));
-    contract.methodsObject.configure({
-        asset: [{
-            fa2_address: tas.address(`tz123`),
-            fa2_batch: [{
-                amount: tas.nat(100),
-                token_id: tas.nat(`100000000000000`),
-            }],
-        }],
-        start_time: tas.timestamp(new Date()),
-        end_time: tas.timestamp(`2020-01-01`),
-        extend_time: tas.nat(10),
-        min_raise: tas.mutez(10),
-        min_raise_percent: tas.nat(10),
-        opening_price: tas.mutez(10),
-        round_time: tas.nat(10),
-    });
-
-};
-```
-
-### Example typegen task
-
-```console
-$ taqueria typegen --typescriptDir ./types
-generateTypes
-{
-  "typescriptDir": "./types"
-}
-Generating Types: /home/rick/projects/crypto/taqueria/example/artifacts => /home/rick/projects/crypto/taqueria/example/types
-Contracts Found:
-        - /home/rick/projects/crypto/taqueria/example/artifacts/example-contract-1.tz
-Processing /example-contract-1.tz...example-contract-1.tz: Types generated
-```
-
-
-### Example type output
-
-```ts
-type Storage = {
-    pauseable_admin?: {
-        admin: address;
-        paused: boolean;
-        pending_admin?: address;
-    };
-    current_id: nat;
-    max_auction_time: nat;
-    max_config_to_start_time: nat;
-    auctions: BigMap<nat, {
-        seller: address;
-        current_bid: mutez;
-        start_time: timestamp;
-        last_bid_time: timestamp;
-        round_time: int;
-        extend_time: int;
-        asset: Array<{
-            fa2_address: address;
-            fa2_batch: Array<{
-                token_id: nat;
-                amount: nat;
-            }>;
-        }>;
-        min_raise_percent: nat;
-        min_raise: mutez;
-        end_time: timestamp;
-        highest_bidder: address;
-    }>;
-};
-
-type Methods = {
-    confirm_admin: () => Promise<void>;
-    pause: (param: boolean) => Promise<void>;
-    set_admin: (param: address) => Promise<void>;
-    bid: (param: nat) => Promise<void>;
-    cancel: (param: nat) => Promise<void>;
-    configure: (
-        opening_price: mutez,
-        min_raise_percent: nat,
-        min_raise: mutez,
-        round_time: nat,
-        extend_time: nat,
-        asset: Array<{
-            fa2_address: address;
-            fa2_batch: Array<{
-                token_id: nat;
-                amount: nat;
-            }>;
-        }>,
-        start_time: timestamp,
-        end_time: timestamp,
-    ) => Promise<void>;
-    resolve: (param: nat) => Promise<void>;
-};
-```
-
-
-## Taquito library changes
-
-See [example-usage.ts](example/example-usage.ts) for full example
-
-### Before
-
-Using taquito with the generated contract types:
-
-The at method can be called providing a type with a utility method that can be provided:
-```ts 
-const contract = await Tezos.contract.at(`tz123`, contractAbstractionComposer<TestContractType>());
-
-// methods can now use typed parameters
-// methodsObject will be able to use type parameters
-```
-
-This can work the same with a wallet
-```ts 
-const contract = await Tezos.wallet.at(`tz123`, walletAbstractionComposer<TestContractType>());
-```
-
-Alternatively, this can be done with a cast:
-```ts
-const contract = await Tezos.contract.at(`tz123`) as ContractProviderFromContractType<TestContractType>;
-```
-
-
-The originate contract does not have any way to provide a type, so this requires a cast:
-```ts
-const originationResult = await Tezos.contract.originate({...});
-const contract = await originationResult.contract(5) as ContractProviderFromContractType<TestContractType2>;
-```
-
-
-For accessing storage, there is no way to pass the type through the contract class, 
-so it requires providing the type again:
-```ts
-const contract = await Tezos.contract.at(`tz123`) as ContractProviderFromContractType<TestContractType>;
-const storage = await contract.storage<StorageFromContractType<TestContractType>>();
-```
-
-
-### After
-
-Extending ContractAbstraction with additional generic types:
-
-The at method can be called with the contract type provided:
-```ts 
-const contract = await Tezos.contract.at<TestContract>(`tz123`);
-
-// methods can now use typed parameters
-// methodsObject will be able to use type parameters
-// storage will be able to use type parameters
-
-```
-
-This can work the same with a wallet
-```ts 
-const contract = await Tezos.wallet.at<TestWalletContract>(`tz123`);
-```
-
-The originate contract now accepts a type:
-```ts
-const originationResult = await Tezos.contract.originate({...});
-const contract = await originationResult.contract<TestContract2>(5);
-```
-
-
-The contract type now also provides the default storage type:
-```ts
-const contract = await Tezos.contract.at<TestContract>(`tz123`);
-const storage = await contract.storage();
-```
-