@ohos-ports/azle 0.33.0-beta.0

package/.scripts/add_metadata_to_dfx_json.js

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const targetDirectory = process.argv[2] || '.'; // Use the provided directory or default to the current directory
+
+const metadataToAdd = [
+    {
+        name: 'candid:service',
+        path: 'src/backend/index.did' // Adjust this path as needed for each canister
+    },
+    {
+        name: 'cdk:name',
+        content: 'azle'
+    }
+];
+
+function updateDfxJson(filePath) {
+    try {
+        const data = readFileSync(filePath, 'utf8');
+        const json = JSON.parse(data);
+
+        // Check each canister in the 'canisters' object
+        for (let canisterName in json.canisters) {
+            let canister = json.canisters[canisterName];
+
+            // Check if the canister has a 'build' property that starts with 'npx azle'
+            if (canister.build && canister.build.startsWith('npx azle')) {
+                // Update the 'metadata' property for this canister
+                canister.metadata = metadataToAdd;
+
+                // Optionally, adjust the 'path' in 'metadata' based on the canister
+                canister.metadata[0].path =
+                    canister.candid || 'specify/candid/path';
+            }
+        }
+
+        writeFileSync(filePath, JSON.stringify(json, null, 4), 'utf8');
+        console.info(`Updated ${filePath}`);
+    } catch (err) {
+        console.error(`Error processing file ${filePath}: ${err}`);
+    }
+}
+
+const entries = readdirSync(targetDirectory, { withFileTypes: true });
+
+entries.forEach((entry) => {
+    if (entry.isDirectory()) {
+        const dfxJsonPath = join(targetDirectory, entry.name, 'dfx.json');
+        if (existsSync(dfxJsonPath)) {
+            updateDfxJson(dfxJsonPath);
+        }
+    }
+});

package/.scripts/cargo_expand.sh

@@ -0,0 +1,17 @@
+# TODO this file is now out of date with the new Docker-based compilation
+
+# To exapand the generated lib file, run each of these commands one by one from inside the azle/examples/canister_name/.azle/canister_name/src direcotry
+# install cargo expand
+RUSTUP_HOME=~/.config/azle/1.68.2 CARGO_HOME=~/.config/azle/1.68.2 CARGO_TARGET_DIR=~/.config/azle/target/ ~/.config/azle/1.68.2/bin/cargo install cargo-expand
+
+# install the nightly compiler
+RUSTUP_HOME=~/.config/azle/1.68.2 CARGO_HOME=~/.config/azle/1.68.2 CARGO_TARGET_DIR=~/.config/azle/target/ ~/.config/azle/1.68.2/bin/rustup default nightly
+
+# revert to the stable compiler
+RUSTUP_HOME=~/.config/azle/1.68.2 CARGO_HOME=~/.config/azle/1.68.2 CARGO_TARGET_DIR=~/.config/azle/target/ ~/.config/azle/1.68.2/bin/rustup default stable
+
+# install wasm32-wasip1
+RUSTUP_HOME=~/.config/azle/1.68.2 CARGO_HOME=~/.config/azle/1.68.2 CARGO_TARGET_DIR=~/.config/azle/target/ ~/.config/azle/1.68.2/bin/rustup target add wasm32-wasip1
+
+# run cargo expand
+RUSTUP_HOME=~/.config/azle/1.68.2 CARGO_HOME=~/.config/azle/1.68.2 CARGO_TARGET_DIR=~/.config/azle/target/ ~/.config/azle/1.68.2/bin/cargo expand --target wasm32-wasip1

package/.scripts/class_migration/add_example_dependency.js

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Get the current directory name
+const currentDirectory = path.basename(process.cwd());
+
+// Define the new dev dependency
+const newDependencyName = `${currentDirectory}_end_to_end_test_functional_syntax`;
+const newDependencyPath = `file:../../functional_syntax/${currentDirectory}`;
+
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Read the package.json file
+fs.readFile(packageJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    // Parse the package.json content
+    let packageJson;
+    try {
+        packageJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    // Ensure devDependencies exists
+    packageJson.devDependencies = packageJson.devDependencies || {};
+
+    // Add the new dev dependency
+    packageJson.devDependencies[newDependencyName] = newDependencyPath;
+
+    // Write the updated package.json back to the file
+    fs.writeFile(
+        packageJsonPath,
+        JSON.stringify(packageJson, null, 2),
+        'utf8',
+        (writeErr) => {
+            if (writeErr) {
+                console.error(
+                    `Error writing updated package.json: ${writeErr}`
+                );
+                return;
+            }
+
+            console.info(
+                `package.json successfully updated with new dev dependency: ${newDependencyName}`
+            );
+        }
+    );
+});

package/.scripts/class_migration/change_to_custom_candid_gen.js

@@ -0,0 +1,76 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Path to the dfx.json file
+const dfxJsonPath = path.join(process.cwd(), 'dfx.json');
+
+// Read the dfx.json file
+fs.readFile(dfxJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading dfx.json file: ${err}`);
+        return;
+    }
+
+    // Parse the dfx.json content
+    let dfxJson;
+    try {
+        dfxJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing dfx.json: ${parseErr}`);
+        return;
+    }
+
+    // Iterate over all canisters
+    const canisters = dfxJson.canisters;
+    if (canisters && typeof canisters === 'object') {
+        Object.keys(canisters).forEach((canisterName) => {
+            const canister = canisters[canisterName];
+
+            // Check if the canister has a candid_gen field
+            if (canister.candid_gen) {
+                canister.candid_gen = 'custom';
+
+                // Check for the main field and construct the candid field
+                if (canister.main) {
+                    const canisterType = canister.type;
+                    const mainPath = canister.main;
+                    const candidPath = mainPath.replace(/\.ts$/, '.did');
+
+                    // Reconstruct the canister object with candid after main
+                    const updatedCanister = {
+                        type: canisterType,
+                        main: mainPath,
+                        candid: candidPath,
+                        ...canister
+                    };
+
+                    // Update the canister in the main dfxJson object
+                    dfxJson.canisters[canisterName] = updatedCanister;
+                } else {
+                    console.error(
+                        `Main field is missing in canister: ${canisterName}`
+                    );
+                }
+            }
+        });
+
+        // Write the updated dfx.json back to the file
+        fs.writeFile(
+            dfxJsonPath,
+            JSON.stringify(dfxJson, null, 2),
+            'utf8',
+            (writeErr) => {
+                if (writeErr) {
+                    console.error(
+                        `Error writing updated dfx.json: ${writeErr}`
+                    );
+                    return;
+                }
+
+                console.info('dfx.json successfully updated.');
+            }
+        );
+    } else {
+        console.error('Canisters field is missing or invalid in dfx.json.');
+    }
+});

package/.scripts/class_migration/clean_package.js

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Directories to be removed
+const directoriesToRemove = ['node_modules', '.azle', '.dfx'];
+
+// Function to remove a directory
+const removeDirectory = (dirPath) => {
+    if (fs.existsSync(dirPath)) {
+        fs.rm(dirPath, { recursive: true, force: true }, (err) => {
+            if (err) {
+                console.error(`Error removing directory ${dirPath}: ${err}`);
+            } else {
+                console.info(`Successfully removed directory: ${dirPath}`);
+            }
+        });
+    } else {
+        console.info(`Directory not found: ${dirPath}`);
+    }
+};
+
+// Remove specified directories
+directoriesToRemove.forEach((dir) => {
+    const fullPath = path.join(process.cwd(), dir);
+    removeDirectory(fullPath);
+});

package/.scripts/class_migration/copy_generated_candid_from_example.js

@@ -0,0 +1,90 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Helper function to copy a file from src to dest
+const copyFile = (src, dest) => {
+    fs.copyFile(src, dest, (err) => {
+        if (err) {
+            console.error(`Error copying file from ${src} to ${dest}: ${err}`);
+        } else {
+            console.info(`File copied from ${src} to ${dest}`);
+        }
+    });
+};
+
+// Path to the dfx.json file
+const dfxJsonPath = path.join(process.cwd(), 'dfx.json');
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Read and parse package.json to find the devDependency path
+fs.readFile(packageJsonPath, 'utf8', (err, packageData) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    let packageJson;
+    try {
+        packageJson = JSON.parse(packageData);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    // Get the current directory name
+    const currentDirectory = path.basename(process.cwd());
+    const devDependencyKey = `${currentDirectory}_end_to_end_test_functional_syntax`;
+    const devDependencyPath = packageJson.devDependencies[devDependencyKey];
+
+    if (!devDependencyPath || !devDependencyPath.startsWith('file:')) {
+        console.error(
+            `DevDependency ${devDependencyKey} not found or invalid in package.json.`
+        );
+        return;
+    }
+
+    const basePath = devDependencyPath.replace('file:', '');
+
+    // Read and parse dfx.json to get canisters and their candid paths
+    fs.readFile(dfxJsonPath, 'utf8', (err, dfxData) => {
+        if (err) {
+            console.error(`Error reading dfx.json file: ${err}`);
+            return;
+        }
+
+        let dfxJson;
+        try {
+            dfxJson = JSON.parse(dfxData);
+        } catch (parseErr) {
+            console.error(`Error parsing dfx.json: ${parseErr}`);
+            return;
+        }
+
+        const canisters = dfxJson.canisters;
+        if (canisters && typeof canisters === 'object') {
+            Object.keys(canisters).forEach((canisterName) => {
+                const canister = canisters[canisterName];
+                if (canister.candid) {
+                    const sourcePath = path.join(
+                        basePath,
+                        '.azle',
+                        canisterName,
+                        'canister',
+                        'src',
+                        'candid.did'
+                    );
+                    const destPath = path.join(process.cwd(), canister.candid);
+                    copyFile(sourcePath, destPath);
+                } else {
+                    console.error(
+                        `Candid field is missing in canister: ${canisterName}`
+                    );
+                }
+            });
+        } else {
+            console.error('Canisters field is missing or invalid in dfx.json.');
+        }
+    });
+});

package/.scripts/class_migration/delete_tests_file.js

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Path to the tests.ts file
+const testsFilePath = path.join(process.cwd(), 'test', 'tests.ts');
+
+// Function to delete the file
+const deleteFile = (filePath) => {
+    fs.unlink(filePath, (err) => {
+        if (err && err.code === 'ENOENT') {
+            console.info(`File not found: ${filePath}`);
+        } else if (err) {
+            console.error(`Error deleting file ${filePath}: ${err}`);
+        } else {
+            console.info(`Successfully deleted file: ${filePath}`);
+        }
+    });
+};
+
+// Delete the tests.ts file
+deleteFile(testsFilePath);

package/.scripts/class_migration/do_all_packages.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { exec } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Get the current directory name
+const currentDirectory = process.cwd();
+
+// Check if a script path is provided as a command-line argument
+const updateScriptPath = process.argv[2];
+
+if (!updateScriptPath) {
+    console.error(
+        'Please provide the path to the script as a command-line argument.\nFor example: node ../.scripts/class_migration/do_all_packages.js ../.scripts/class_migration/name_package.js'
+    );
+    process.exit(1);
+}
+const fullScriptPath = path.resolve(updateScriptPath);
+console.info(fullScriptPath);
+
+// Read all subdirectories in the current directory
+fs.readdir(currentDirectory, (err, files) => {
+    if (err) {
+        console.error(`Error reading directory: ${err}`);
+        return;
+    }
+
+    files.forEach((file) => {
+        const fullPath = path.join(currentDirectory, file);
+
+        // Check if the current file is a directory
+        if (fs.lstatSync(fullPath).isDirectory()) {
+            // Run the update script in the current directory
+            exec(
+                `node ${fullScriptPath}`,
+                { cwd: fullPath },
+                (execErr, stdout, stderr) => {
+                    if (execErr) {
+                        console.error(
+                            `Error executing script in directory ${file}: ${execErr}`
+                        );
+                        return;
+                    }
+
+                    if (stderr) {
+                        console.error(
+                            `Error in script output for directory ${file}: ${stderr}`
+                        );
+                        return;
+                    }
+
+                    console.info(
+                        `Successfully updated package in directory ${file}`
+                    );
+                    console.info(stdout);
+                }
+            );
+        }
+    });
+});

package/.scripts/class_migration/modify_pretest.js

@@ -0,0 +1,57 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Path to the pretest.ts file
+const pretestFilePath = path.join(process.cwd(), 'test', 'pretest.ts');
+
+const currentDirectory = path.basename(process.cwd());
+
+// Lines to add at the top of the file
+const importLines = [
+    "import { linkAndInstallPatch } from 'azle/_internal/test/jest_link';",
+    "import { join } from 'path';"
+];
+
+// Line to add after function pretest(): void {
+const additionalLine = `    linkAndInstallPatch(join('tests', 'end_to_end', 'candid_rpc', 'functional_syntax', '${currentDirectory}'));\n`;
+
+// Read the pretest.ts file
+fs.readFile(pretestFilePath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading pretest.ts file: ${err}`);
+        return;
+    }
+
+    // Split the file content into lines
+    const lines = data.split('\n');
+
+    // Find the index where function pretest(): void { is defined
+    const pretestIndex = lines.findIndex((line) =>
+        line.trim().startsWith('function pretest(): void {')
+    );
+    if (pretestIndex === -1) {
+        console.error('Async function pretest() not found in pretest.ts file.');
+        return;
+    }
+
+    // Insert import lines at the beginning of the file
+    lines.splice(0, 0, ...importLines);
+
+    // Insert additional line after function pretest(): void {
+    lines.splice(pretestIndex + 3, 0, additionalLine);
+
+    // Join the lines back into a single string
+    const modifiedContent = lines.join('\n');
+
+    // Write the modified content back to the file
+    fs.writeFile(pretestFilePath, modifiedContent, 'utf8', (writeErr) => {
+        if (writeErr) {
+            console.error(
+                `Error writing modified pretest.ts file: ${writeErr}`
+            );
+            return;
+        } else {
+            console.info('pretest.ts successfully modified.');
+        }
+    });
+});

package/.scripts/class_migration/name_package.js

@@ -0,0 +1,62 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Get the current directory name
+const currentDirectory = path.basename(process.cwd());
+
+// Define the new name for the package
+const newName = `${currentDirectory}_end_to_end_test_functional_syntax`;
+
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Read the package.json file
+fs.readFile(packageJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    // Parse the package.json content
+    let packageJson;
+    try {
+        packageJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    // Check if express is listed as a dependency
+    const hasExpressDependency =
+        packageJson.dependencies && packageJson.dependencies.express;
+    if (hasExpressDependency) {
+        console.info(
+            'Express is listed as a dependency. No changes will be made.'
+        );
+        return;
+    }
+
+    // Create a new object with the name field first
+    const updatedPackageJson = {
+        name: newName,
+        ...packageJson
+    };
+
+    // Write the updated package.json back to the file
+    fs.writeFile(
+        packageJsonPath,
+        JSON.stringify(updatedPackageJson, null, 2),
+        'utf8',
+        (writeErr) => {
+            if (writeErr) {
+                console.error(
+                    `Error writing updated package.json: ${writeErr}`
+                );
+                return;
+            }
+            console.info(
+                `package.json successfully updated with new name: ${newName}`
+            );
+        }
+    );
+});

package/.scripts/class_migration/update_test.js

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Get the current directory name
+const currentDirectory = path.basename(process.cwd());
+
+// Path to the test.ts file
+const testFilePath = path.join(process.cwd(), 'test', 'test.ts');
+
+// Existing import statement to remove
+const existingImportStatement = "import { getTests } from './tests';";
+
+// New import statement to add
+const newImportStatement = `import { getTests } from '${currentDirectory}_end_to_end_test_functional_syntax/test/tests';`;
+
+// Read the test.ts file
+fs.readFile(testFilePath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading test.ts file: ${err}`);
+        return;
+    }
+
+    // Replace the existing import statement with the new one
+    const modifiedContent = data.replace(
+        existingImportStatement,
+        newImportStatement
+    );
+
+    // Write the modified content back to the file
+    fs.writeFile(testFilePath, modifiedContent, 'utf8', (writeErr) => {
+        if (writeErr) {
+            console.error(`Error writing modified test.ts file: ${writeErr}`);
+            return;
+        }
+
+        console.info('test.ts successfully modified.');
+    });
+});

package/.scripts/class_migration/update_ts_config.js

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Path to the tsconfig.json file
+const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+
+// Read the tsconfig.json file
+fs.readFile(tsconfigPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading tsconfig.json file: ${err}`);
+        return;
+    }
+
+    // Parse the tsconfig.json content
+    let tsconfig;
+    try {
+        tsconfig = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing tsconfig.json: ${parseErr}`);
+        return;
+    }
+
+    // Ensure compilerOptions exists
+    tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+
+    // Add the required options
+    tsconfig.compilerOptions.experimentalDecorators = true;
+    tsconfig.compilerOptions.preserveSymlinks = true;
+
+    // Write the updated tsconfig.json back to the file
+    fs.writeFile(
+        tsconfigPath,
+        JSON.stringify(tsconfig, null, 2),
+        'utf8',
+        (writeErr) => {
+            if (writeErr) {
+                console.error(
+                    `Error writing updated tsconfig.json: ${writeErr}`
+                );
+                return;
+            }
+
+            console.info(
+                'tsconfig.json successfully updated with experimentalDecorators and preserveSymlinks options.'
+            );
+        }
+    );
+});