@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/build/utils/log_success.ts

@@ -0,0 +1,18 @@
+import '#experimental/build/assert_experimental';
+
+import { execSyncPretty } from '#utils/exec_sync_pretty';
+
+export function logSuccess(canisterName: string, canisterId: string): void {
+    const replicaWebServerPort = execSyncPretty(`dfx info webserver-port`)
+        .toString()
+        .trim();
+
+    const url =
+        process.env.DFX_NETWORK === 'ic'
+            ? `https://${canisterId}.raw.icp0.io`
+            : `http://${canisterId}.raw.localhost:${replicaWebServerPort}`;
+
+    console.info(
+        `\nCanister ${canisterName} serving HTTP requests at: ${url}\n`
+    );
+}

package/src/experimental/build/utils/types.ts

@@ -0,0 +1,34 @@
+import '#experimental/build/assert_experimental';
+
+import {
+    CanisterConfig as StableCanisterConfig,
+    Context as StableContext,
+    CustomConfig as StableCustomConfig,
+    WasmData as StableWasmData
+} from '#utils/types';
+
+export type Context = {
+    canisterId: string;
+    esmAliases: Record<string, string>;
+    esmExternals: string[];
+    reloadedJsPath: string;
+    wasmData: WasmData;
+} & StableContext;
+
+export type WasmData = {
+    managementDid: string;
+} & StableWasmData;
+
+export type CustomConfig = Omit<
+    StableCustomConfig,
+    'assets' | 'build_assets' | 'esm_aliases' | 'esm_externals'
+> & {
+    assets?: [string, string][];
+    build_assets?: string;
+    esm_aliases?: Record<string, string>;
+    esm_externals?: string[];
+};
+
+export type CanisterConfig = Omit<StableCanisterConfig, 'custom'> & {
+    custom?: CustomConfig;
+};

package/src/experimental/lib/assert_experimental.ts

@@ -0,0 +1,19 @@
+if (globalThis._azleExperimental !== true) {
+    throw new Error(experimentalMessage());
+}
+
+function experimentalMessage(): string {
+    return `Azle: experimental mode must be enabled to import from azle/experimental. You can enable experimental mode in your dfx.json file like this:
+{
+    "canisters": {
+        "canisterName": {
+            "type": "azle",
+            "main": "index.ts",
+            "custom": {
+                "experimental": true
+            }
+        }
+    }
+}
+`;
+}

package/src/experimental/lib/fetch/file.ts

@@ -0,0 +1,15 @@
+import '#experimental/lib/assert_experimental';
+
+import { readFile } from 'fs/promises';
+
+import { AzleFetchResponse } from './response';
+import { getUrl } from './url';
+
+export async function fetchFile(input: RequestInfo | URL): Promise<Response> {
+    const url = getUrl(input);
+
+    const path = `${url.hostname}${url.pathname}`;
+    const contents = await readFile(path);
+
+    return new AzleFetchResponse(new Uint8Array(contents));
+}

package/src/experimental/lib/fetch/headers.ts

@@ -0,0 +1,85 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO this is meant to be basic for now
+export class AzleFetchHeaders {
+    headers: {
+        [key: string]: string;
+    } = {};
+
+    [Symbol.iterator](): HeadersIterator<[string, string]> {
+        return this.entries();
+    }
+
+    constructor(headers?: HeadersInit) {
+        if (Array.isArray(headers)) {
+            this.headers = headers.reduce((acc, [key, value]) => {
+                return {
+                    ...acc,
+                    [key]: value
+                };
+            }, {});
+        }
+
+        if (headers instanceof AzleFetchHeaders) {
+            this.headers = headers.headers;
+        }
+
+        if (typeof headers === 'object') {
+            this.headers = headers as AzleFetchHeaders['headers']; // TODO it would be nice to get rid of this cast
+        }
+    }
+
+    // TODO append seems a bit complicated to implement because we have to know which
+    // TODO headers can accept multiple values
+    append(): void {
+        throw new Error(`AzleFetchHeaders: append is not yet implemented`);
+    }
+
+    // TODO we do not throw here like the documentation says we should
+    delete(name: string): void {
+        delete this.headers[name];
+    }
+
+    entries(): HeadersIterator<[string, string]> {
+        return Object.entries(this.headers)[Symbol.iterator]();
+    }
+
+    forEach(
+        callback: (
+            value: string,
+            key: string,
+            headers: AzleFetchHeaders
+        ) => any,
+        thisArg: any = this // TODO is this the correct this?
+    ): void {
+        Object.entries(this.headers).forEach(([key, value]) => {
+            callback.bind(thisArg)(value, key, this);
+        });
+    }
+
+    get(name: string): string {
+        return this.headers[name] ?? null;
+    }
+
+    getSetCookie(): string[] {
+        throw new Error(
+            `AzleFetchHeaders: getSetCookie is not yet implemented`
+        );
+    }
+
+    has(name: string): boolean {
+        return this.headers[name] !== undefined;
+    }
+
+    keys(): HeadersIterator<string> {
+        return Object.keys(this.headers)[Symbol.iterator]();
+    }
+
+    set(name: string, value: string): void {
+        this.headers[name] = value;
+    }
+
+    values(): HeadersIterator<string> {
+        return Object.values(this.headers)[Symbol.iterator]();
+    }
+}

package/src/experimental/lib/fetch/http.ts

@@ -0,0 +1,293 @@
+import '#experimental/lib/assert_experimental';
+
+import { inflate } from 'pako';
+
+import { http_transform } from '#lib/canisters/management/idl/index';
+import { canisterSelf } from '#lib/ic_apis/canister_self';
+
+import { azleFetch, serialize } from '.';
+import { AzleFetchResponse } from './response';
+import { getUrl } from './url';
+
+export type CandidHttpResponse = {
+    status: bigint;
+    headers: CandidHttpHeader[];
+    body: Uint8Array;
+};
+
+export type CandidHttpHeader = {
+    name: string;
+    value: string;
+};
+
+export async function fetchHttp(
+    input: RequestInfo | URL,
+    init?: RequestInit | undefined
+): Promise<Response> {
+    const urlObject = getUrl(input);
+    const url = `${urlObject.origin}${urlObject.pathname}${urlObject.search}`; // For some sad reason toString() on our URL object from wasmedge-quickjs doesn't return the fully formatted URL as as tring, it returns [object Object]
+    const maxResponseBytes = getHttpMaxResponseBytes();
+    const method = getHttpMethod(init);
+    const headers = getHeaders(init);
+    const body = await prepareRequestBody(init);
+    const transform = getHttpTransform();
+    const cycles = getCycles(body[0], headers, maxResponseBytes[0]);
+
+    const response = await azleFetch(`icp://aaaaa-aa/http_request`, {
+        body: serialize({
+            args: [
+                {
+                    url,
+                    max_response_bytes: maxResponseBytes,
+                    method,
+                    headers,
+                    body,
+                    transform
+                }
+            ],
+            cycles
+        })
+    });
+    const responseJson: CandidHttpResponse = await response.json();
+
+    const bodyIsGZipped =
+        responseJson.headers.find(({ name, value }) => {
+            return (
+                name.toLowerCase() === 'content-encoding' &&
+                value.toLowerCase() === 'gzip'
+            );
+        }) !== undefined;
+
+    const unGZippedBody = bodyIsGZipped
+        ? inflate(responseJson.body)
+        : responseJson.body;
+
+    // TODO do we need to handle chunked bodies at all?
+    // TODO do we need to handle a chunked body on the frontend too?
+    // TODO if so we can use the transfer-encoding chunked processing in server.ts
+    // TODO seems the reason I did this was obviated after gzipping
+    // TODO gzipping handled the chunked encoding and produced a full body
+    // TODO but I assume it is possible for a chunked non-gzipped body to occur too
+    // const bodyIsChunked =
+    //     responseJson.headers.find(({ name, value }) => {
+    //         return (
+    //             name.toLowerCase() === 'transfer-encoding' &&
+    //             value.toLowerCase() === 'chunked'
+    //         );
+    //     }) !== undefined;
+
+    const finalBody = new Uint8Array(unGZippedBody);
+
+    const responseHeaders = responseJson.headers.reduce(
+        (acc, { name, value }) => {
+            return {
+                ...acc,
+                [name]: value
+            };
+        },
+        {}
+    );
+
+    // Using Response from wasmedge-quickjs doesn't seem ideal for the time being
+    // It seems very tied to the low-level implementation at first glance
+    // We will build up our own response for the time being
+    return new AzleFetchResponse(finalBody, {
+        status: Number(responseJson.status),
+        headers: responseHeaders
+    });
+}
+
+function getHttpMaxResponseBytes(): [] | [bigint] {
+    return globalThis._azleOutgoingHttpOptionsMaxResponseBytes === undefined
+        ? []
+        : [globalThis._azleOutgoingHttpOptionsMaxResponseBytes];
+}
+
+// TODO We may need a union for the type of init.method in order to address the TODO below
+// TODO make this function's return type explicit https://github.com/demergent-labs/azle/issues/1860
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function getHttpMethod(init?: RequestInit | undefined) {
+    if (init === undefined) {
+        return {
+            get: null
+        };
+    }
+
+    if (init.method === undefined) {
+        return {
+            get: null
+        };
+    }
+
+    if (
+        init.method.toLowerCase() !== 'get' &&
+        init.method.toLowerCase() !== 'head' &&
+        init.method.toLowerCase() !== 'post'
+    ) {
+        throw new Error(
+            `azleFetch: ${init.method} is not a supported HTTP method`
+        );
+    }
+
+    return {
+        [init.method.toLowerCase()]: null
+    };
+}
+
+function getHttpTransform(): [] | [http_transform] {
+    if (globalThis._azleOutgoingHttpOptionsTransformMethodName === undefined) {
+        return [];
+    }
+
+    return [
+        {
+            function: [
+                canisterSelf(),
+                globalThis._azleOutgoingHttpOptionsTransformMethodName
+            ],
+            context:
+                globalThis._azleOutgoingHttpOptionsTransformContext ??
+                Uint8Array.from([])
+        }
+    ];
+}
+
+// Calculated according to: https://internetcomputer.org/docs/current/developer-docs/gas-cost#special-features
+// and https://forum.dfinity.org/t/a-new-price-function-for-https-outcalls/20838
+function getCycles(
+    body: Uint8Array | undefined,
+    headers: CandidHttpHeader[],
+    maxResponseBytes: bigint | undefined
+): bigint {
+    const subnetSize = BigInt(
+        globalThis._azleOutgoingHttpOptionsSubnetSize ?? 13
+    );
+    const baseFeeEstimate = (3_000_000n + 60_000n * subnetSize) * subnetSize;
+
+    const concatenatedHeaders = headers.reduce(
+        (acc, { name, value }) => `${acc}${name}${value}`,
+        ''
+    );
+    const headersSize = BigInt(Buffer.byteLength(concatenatedHeaders, 'utf-8'));
+    const bodySize = BigInt(body?.length ?? 0);
+    const requestSize = headersSize + bodySize;
+    const requestFeeEstimate = 400n * subnetSize * requestSize;
+
+    const responseFeeEstimate =
+        800n * subnetSize * (maxResponseBytes ?? 2_000_000n);
+
+    const totalFeeEstimate =
+        baseFeeEstimate + requestFeeEstimate + responseFeeEstimate;
+
+    return globalThis._azleOutgoingHttpOptionsCycles ?? totalFeeEstimate;
+}
+
+// TODO I have decided to leave a lot of these objects even though they may not exist
+// TODO we'll have to add these over time, the ones that make sense
+// TODO some of these instanceof checks might break
+// TODO some of those objects might not exist in QuickJS/wasmedge-quickjs
+async function prepareRequestBody(
+    init: RequestInit | undefined
+): Promise<[Uint8Array] | []> {
+    if (init === undefined) {
+        return [];
+    }
+
+    if (init.body === null) {
+        return [];
+    }
+
+    if (init.body === undefined) {
+        return [];
+    }
+
+    if (typeof init.body === 'string') {
+        const textEncoder = new TextEncoder();
+        return [textEncoder.encode(init.body)];
+    }
+
+    if (
+        init.body instanceof BigUint64Array ||
+        init.body instanceof BigInt64Array
+    ) {
+        return [new Uint8Array(init.body.buffer)];
+    }
+
+    if (init.body instanceof Uint8Array) {
+        return [init.body];
+    }
+
+    if (
+        init.body instanceof ArrayBuffer ||
+        init.body instanceof Uint8ClampedArray ||
+        init.body instanceof Uint16Array ||
+        init.body instanceof Uint32Array ||
+        init.body instanceof Int8Array ||
+        init.body instanceof Int16Array ||
+        init.body instanceof Int32Array ||
+        init.body instanceof Float32Array ||
+        init.body instanceof Float64Array
+    ) {
+        return [new Uint8Array(init.body)];
+    }
+
+    if (init.body instanceof DataView) {
+        return [new Uint8Array(init.body.buffer)];
+    }
+
+    if (init.body instanceof Blob) {
+        return [new Uint8Array(await init.body.arrayBuffer())];
+    }
+
+    if (init.body instanceof File) {
+        const blob = new Blob([init.body], { type: init.body.type });
+        const buffer = await blob.arrayBuffer();
+        return [new Uint8Array(buffer)];
+    }
+
+    if (init.body instanceof URLSearchParams) {
+        const encoder = new TextEncoder();
+        return [encoder.encode(init.body.toString())];
+    }
+
+    if (init.body instanceof FormData) {
+        throw new Error(`azleFetch: FormData is not a supported body type`);
+    }
+
+    throw new Error(`azleFetch: Not a supported body type`);
+}
+
+function getHeaders(init: RequestInit | undefined): CandidHttpHeader[] {
+    if (init === undefined) {
+        return [];
+    }
+
+    if (init.headers === undefined) {
+        return [];
+    }
+
+    if (Array.isArray(init.headers)) {
+        return init.headers.map(([key, value]) => {
+            return {
+                name: key,
+                value
+            };
+        });
+    }
+
+    if (typeof init.headers === 'object') {
+        return Object.entries(init.headers).map(([key, value]) => {
+            return {
+                name: key,
+                value
+            };
+        });
+    }
+
+    // TODO we do not currently have a Headers object
+    // if (init.headers instanceof Headers) {
+    //     throw new Error(`azleFetch: Headers is not a supported headers type`);
+    // }
+
+    throw new Error(`azleFetch: not a supported headers type`);
+}

package/src/experimental/lib/fetch/icp.ts

@@ -0,0 +1,98 @@
+import '#experimental/lib/assert_experimental';
+
+import { IDL } from '@dfinity/candid';
+import { Principal } from '@dfinity/principal';
+
+import { call } from '#lib/ic_apis/index';
+
+import { ic } from '../ic';
+import { getUrl } from './url';
+
+export async function fetchIcp(
+    input: RequestInfo | URL,
+    init?: RequestInit | undefined
+): Promise<Response> {
+    const url = getUrl(input);
+
+    const canisterId = url.hostname;
+    const canisterMethod = url.pathname.replace('/', '');
+
+    const { body } = init ?? {};
+    const { args, cycles } = (body ?? {}) as any;
+    const candidPath = determineCandidPath(
+        canisterId,
+        (body as any)?.candidPath
+    );
+
+    const idlString = ic.candidCompiler(candidPath);
+
+    const normalizedIdlString = idlString
+        .replace(/export const idlFactory/g, 'const idlFactory')
+        .replace(/export const init/g, 'const init');
+
+    const idlFactory = eval(`
+        try {
+            ${normalizedIdlString}
+
+            idlFactory;
+        }
+        catch(error) {
+            console.info('eval error');
+            console.info(error);
+        }
+    `);
+
+    const serviceIdl = idlFactory({ IDL });
+
+    const [_funcName, funcIdl] = serviceIdl._fields.find(
+        ([funcName]: [string, IDL.Type]) => funcName === canisterMethod
+    );
+
+    const argsRaw = new Uint8Array(IDL.encode(funcIdl.argTypes, args ?? []));
+
+    const canisterPrincipal = Principal.fromText(canisterId);
+
+    const result = await call<Uint8Array, Uint8Array>(
+        canisterPrincipal,
+        canisterMethod,
+        {
+            args: argsRaw,
+            cycles: BigInt(cycles ?? 0),
+            raw: true
+        }
+    );
+
+    const decodedResult = IDL.decode(funcIdl.retTypes, result);
+
+    // Using Response from wasmedge-quickjs doesn't seem ideal for the time being
+    // It seems very tied to the low-level implementation at first glance
+    // We will build up our own response for the time being
+    // TODO we are not using AzleFetchResponse here because the json method
+    // TODO need to return the Candid decoded object
+    return {
+        ok: true,
+        arrayBuffer: async () => {
+            return result.buffer;
+        },
+        json: async () => {
+            return decodedResult[0];
+        },
+        text: async () => {
+            return Buffer.from(result.buffer).toString();
+        }
+    } as any;
+}
+
+function determineCandidPath(canisterId: string, candidPath?: string): string {
+    if (candidPath !== undefined) {
+        return candidPath;
+    }
+
+    if (canisterId === 'aaaaa-aa') {
+        return `/candid/icp/management.did`;
+    }
+
+    throw new Error(
+        "azleFetch: Candid path doesn't exist, please specify a valid candid path"
+    );
+}

package/src/experimental/lib/fetch/index.ts

@@ -0,0 +1,97 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO what happens if you have a bunch of fetches in your dependencies, all in a row?
+// TODO how would you set options for each individually?
+// TODO it seems like you might not be able to do that
+// TODO we have got to get rid of the need to set all of these custom things
+import { fetchFile } from './file';
+import { fetchHttp } from './http';
+import { fetchIcp } from './icp';
+import { getUrl } from './url';
+
+export async function azleFetch(
+    input: RequestInfo | URL,
+    init?: RequestInit | undefined
+): Promise<Response> {
+    logWarnings(init);
+
+    if (process.env.AZLE_TEST_FETCH === 'true') {
+        console.info('azleFetch has been called');
+    }
+
+    const url = getUrl(input);
+
+    if (url.protocol === 'file:') {
+        return await fetchFile(input);
+    }
+
+    if (url.protocol === 'https:') {
+        return await fetchHttp(input, init);
+    }
+
+    if (url.protocol === 'icp:') {
+        return await fetchIcp(input, init);
+    }
+
+    throw new Error(`azleFetch: protocol ${url.protocol} not supported`);
+}
+
+export function serialize(param: {
+    candidPath?: string;
+    args?: any[];
+    cycles?: number | bigint;
+}): ArrayBuffer {
+    return param as any;
+}
+
+function logWarnings(init?: RequestInit | undefined): void {
+    if (init === undefined) {
+        return;
+    }
+
+    if (init.cache !== undefined) {
+        logWarning(`cache`);
+    }
+
+    if (init.credentials !== undefined) {
+        logWarning(`credentials`);
+    }
+
+    if (init.integrity !== undefined) {
+        logWarning(`integrity`);
+    }
+
+    if (init.keepalive !== undefined) {
+        logWarning(`keepalive`);
+    }
+
+    if (init.mode !== undefined) {
+        logWarning(`mode`);
+    }
+
+    if (init.redirect !== undefined) {
+        logWarning(`redirect`);
+    }
+
+    if (init.referrer !== undefined) {
+        logWarning(`referrer`);
+    }
+
+    if (init.referrerPolicy !== undefined) {
+        logWarning(`referrerPolicy`);
+    }
+
+    if (init.signal !== undefined) {
+        logWarning(`signal`);
+    }
+
+    if (init.window !== undefined) {
+        logWarning(`window`);
+    }
+}
+
+function logWarning(method: string): void {
+    console.warn(
+        `azleFetch: init.${method} has no effect when using an identity as the Authorization header`
+    );
+}