@ohos-ports/azle 0.33.0-beta.0

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

@@ -0,0 +1,171 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO We currently do not have an implementation of ReadableStream
+// TODO thus our body is done with Uint8Array or Buffer
+import { AzleFetchHeaders } from './headers';
+
+// 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
+export class AzleFetchResponse {
+    url: Response['url'];
+    ok: Response['ok'];
+    type: Response['type'];
+    redirected: Response['redirected'];
+    status: Response['status'];
+    statusText: Response['statusText'];
+    headers: Response['headers'];
+    body: Response['body'] = null;
+    bodyUsed: Response['bodyUsed'];
+
+    constructor(body?: BodyInit, init?: ResponseInit) {
+        this.body = convertBodyInitToBody(body);
+        this.status = init?.status ?? 200;
+        this.statusText = getStatusText(this.status);
+        this.ok = this.status >= 200 && this.status <= 299;
+        this.type = '' as any; // TODO we should work to set this appropriately
+        this.redirected = false; // TODO we are defaulting to false, I believe we would have to implement automatic redirects for this to ever be true
+        this.bodyUsed = false;
+        this.headers = new AzleFetchHeaders(init?.headers);
+        this.url = ''; // TODO I do not understand how this is supposed to be set, as it is a readon-only property and the Respone constructor does not allow you to pass in the URL
+    }
+
+    async arrayBuffer(): Promise<ArrayBuffer> {
+        this.bodyUsed = true;
+
+        if (this.body === null) {
+            return new ArrayBuffer(0);
+        }
+
+        const result = this.body as unknown as Uint8Array | Buffer;
+
+        return result.buffer instanceof ArrayBuffer
+            ? result.buffer
+            : new Uint8Array(result).buffer;
+    }
+
+    async bytes(): Promise<Uint8Array<ArrayBuffer>> {
+        this.bodyUsed = true;
+
+        if (this.body === null) {
+            return new Uint8Array();
+        }
+
+        return new Uint8Array(this.body as unknown as Uint8Array | Buffer);
+    }
+
+    async json(): Promise<string> {
+        this.bodyUsed = true;
+
+        if (this.body === null) {
+            return JSON.parse('');
+        }
+
+        return JSON.parse(
+            (this.body as unknown as Uint8Array | Buffer).toString()
+        );
+    }
+
+    async text(): Promise<string> {
+        this.bodyUsed = true;
+
+        if (this.body === null) {
+            return '';
+        }
+
+        return (this.body as unknown as Uint8Array | Buffer).toString();
+    }
+
+    async blob(): Promise<Blob> {
+        throw new Error(`AzleFetchResponse: blob is not yet implemented`);
+    }
+
+    async formData(): Promise<FormData> {
+        throw new Error(`AzleFetchResponse: formData is not yet implemented`);
+    }
+
+    clone(): AzleFetchResponse {
+        return new AzleFetchResponse();
+    }
+}
+
+function convertBodyInitToBody(body?: BodyInit): Response['body'] {
+    if (body === undefined) {
+        return null;
+    }
+
+    if (body instanceof Uint8Array || body instanceof Buffer) {
+        return Buffer.from(body) as unknown as Response['body'];
+    }
+
+    throw new Error(`AzleFetchResponse: body must be a Uint8Array or Buffer`);
+}
+
+function getStatusText(status: number): string {
+    const statusTexts: {
+        [key: number]: string;
+    } = {
+        100: 'Continue',
+        101: 'Switching Protocols',
+        102: 'Processing',
+        103: 'Early Hints',
+        200: 'OK',
+        201: 'Created',
+        202: 'Accepted',
+        203: 'Non-Authoritative Information',
+        204: 'No Content',
+        205: 'Reset Content',
+        206: 'Partial Content',
+        207: 'Multi-Status',
+        208: 'Already Reported',
+        226: 'IM Used',
+        300: 'Multiple Choices',
+        301: 'Moved Permanently',
+        302: 'Found',
+        303: 'See Other',
+        304: 'Not Modified',
+        306: 'unused',
+        307: 'Temporary Redirect',
+        308: 'Permanent Redirect',
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        405: 'Method Not Allowed',
+        406: 'Not Acceptable',
+        407: 'Proxy Authentication Required',
+        408: 'Request Timeout',
+        409: 'Conflict',
+        410: 'Gone',
+        411: 'Length Required',
+        412: 'Precondition Failed',
+        413: 'Payload Too Large',
+        414: 'URI Too Long',
+        415: 'Unsupported Media Type',
+        416: 'Range Not Satisfiable',
+        417: 'Expectation Failed',
+        418: "I'm a teapot",
+        421: 'Misdirected Request',
+        422: 'Unprocessable Content',
+        423: 'Locked',
+        424: 'Failed Dependency',
+        426: 'Upgrade Required',
+        428: 'Precondition Required',
+        429: 'Too Many Requests',
+        431: 'Request Header Fields Too Large',
+        451: 'Unavailable For Legal Reasons',
+        500: 'Internal Server Error',
+        501: 'Not Implemented',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        504: 'Gateway Timeout',
+        505: 'HTTP Version Not Supported',
+        506: 'Variant Also Negotiates',
+        507: 'Insufficient Storage',
+        508: 'Loop Detected',
+        510: 'Not Extended',
+        511: 'Network Authentication Required'
+    };
+
+    return statusTexts[status] ?? '';
+}

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

@@ -0,0 +1,15 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO we do not support Request yet, same as the frontend fetch
+// TODO we probably could as wasmedge-quickjs has a Request class in http
+export function getUrl(input: RequestInfo | URL): URL {
+    if (input instanceof URL) {
+        return input;
+    }
+
+    if (typeof input === 'string') {
+        return new URL(input);
+    }
+
+    throw new Error(`azleFetch: input must be of type URL or string`);
+}

package/src/experimental/lib/globals.ts

@@ -0,0 +1,146 @@
+import '#experimental/lib/assert_experimental';
+import '#lib/globals'; // We import this to remove type errors having to do with the stable and experimental globals
+
+// @ts-ignore
+import { TextDecoder, TextEncoder } from '@sinonjs/text-encoding';
+import { Buffer } from 'buffer';
+import * as process from 'process';
+import { URL } from 'url';
+import { v4 } from 'uuid';
+
+import { azleFetch } from './fetch';
+
+export type Callbacks = {
+    [key: string]: (...args: any) => any;
+};
+
+declare global {
+    var _azleOutgoingHttpOptionsSubnetSize: number | undefined;
+    var _azleOutgoingHttpOptionsMaxResponseBytes: bigint | undefined;
+    var _azleOutgoingHttpOptionsCycles: bigint | undefined;
+    var _azleOutgoingHttpOptionsTransformMethodName: string | undefined;
+    var _azleOutgoingHttpOptionsTransformContext: Uint8Array | undefined;
+    var _azleWebAssembly: any | undefined;
+}
+
+if (
+    globalThis._azleIcpReplicaWasmEnvironment === true ||
+    globalThis._azleNodejsWasmEnvironment === true
+) {
+    // Even though these are set in #lib/globals
+    // we must set them again here because importing the url module above
+    // seemingly resets globalThis.TextDecoder and globalThis.TextEncoder
+    // to the wasmedge-quickjs versions which break with a RangeError: The "ascii" encoding is not supported
+    globalThis.TextDecoder = TextDecoder;
+    globalThis.TextEncoder = TextEncoder;
+
+    globalThis.window = globalThis as any;
+
+    const originalSetTimeout = setTimeout;
+
+    (globalThis as any).setTimeout = (
+        handler: TimerHandler,
+        timeout?: number
+    ): number => {
+        if (timeout !== undefined && timeout !== 0) {
+            console.warn(
+                `Azle Warning: setTimeout may not behave as expected with milliseconds above 0; called with ${timeout} milliseconds`,
+                new Error().stack
+            );
+        }
+
+        return originalSetTimeout(handler, 0);
+    };
+
+    globalThis.Buffer = Buffer;
+
+    globalThis.process = process;
+
+    // TODO These write implementations are not correct, they are just good enough
+    // TODO to get NestJS logging looking pretty good
+    globalThis.process = {
+        ...process,
+        stdout: {
+            write: (message: string) => {
+                stdioWrite(message);
+            }
+        } as any,
+        stderr: {
+            write: (message: string) => {
+                stdioWrite(message);
+            }
+        } as any
+    };
+
+    globalThis.clearInterval = (): void => {}; // TODO should this throw an error or just not do anything? At least a warning would be good right?
+
+    globalThis.global = globalThis;
+    (globalThis as any).self = globalThis;
+
+    globalThis.TypeError = globalThis.Error;
+
+    globalThis.WebAssembly = {
+        instantiate: (...args: any[]) => {
+            if (globalThis._azleWebAssembly === undefined) {
+                throw new Error('globalThis._azleWebAssembly is undefined');
+            }
+
+            const uuid = v4();
+
+            const instantiatedSource = globalThis._azleWebAssembly.instantiate(
+                uuid,
+                ...args
+            );
+            const exportEntries = Object.entries(
+                instantiatedSource.instance.exports
+            );
+
+            for (const [key, value] of exportEntries) {
+                if (typeof value === 'function') {
+                    instantiatedSource.instance.exports[key] = value.bind({
+                        instanceUuid: uuid,
+                        exportName: key
+                    });
+                }
+            }
+
+            return instantiatedSource;
+        }
+    } as any;
+
+    (globalThis as any).fetch = azleFetch;
+
+    (globalThis as any).URL = URL;
+
+    // Unfortunately NestJS needs RegExp.leftContext to work
+    const originalExec = RegExp.prototype.exec;
+
+    Object.defineProperty(RegExp.prototype, 'leftContext', {
+        value: '',
+        writable: true,
+        configurable: true
+    });
+
+    RegExp.prototype.exec = function (string): RegExpExecArray | null {
+        const match = originalExec.call(this, string);
+        if (match !== null) {
+            RegExp.leftContext = (string ?? '').substring(0, match.index);
+        }
+        return match;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    global.Intl = require('intl');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require('intl/locale-data/jsonp/en.js');
+}
+
+function stdioWrite(message: string): void {
+    // eslint-disable-next-line
+    const ansiEscapeRegex = /\u001b\[.*?m/g;
+    const newlineRegex = /\n/g;
+    const messageAnsiCodesRemoved = message
+        .replace(ansiEscapeRegex, '')
+        .replace(newlineRegex, '');
+    console.info(messageAnsiCodesRemoved);
+}

package/src/experimental/lib/http_client/fetch_ic/actor.ts

@@ -0,0 +1,131 @@
+import { Actor, ActorMethod, ActorSubclass, Identity } from '@dfinity/agent';
+import type { Principal } from '@dfinity/principal';
+
+import { createAgent } from './agent';
+
+export async function createActor(
+    identity: Identity,
+    canisterId: string,
+    host: string
+): Promise<ActorSubclass<_SERVICE>> {
+    const agent = await createAgent(identity, host);
+
+    return Actor.createActor<_SERVICE>(
+        ({ IDL }) => {
+            const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+
+            const HttpRequest = IDL.Record({
+                method: IDL.Text,
+                url: IDL.Text,
+                headers: IDL.Vec(HeaderField),
+                body: IDL.Vec(IDL.Nat8),
+                certificate_version: IDL.Opt(IDL.Nat16)
+            });
+
+            const HttpUpdateRequest = IDL.Record({
+                method: IDL.Text,
+                url: IDL.Text,
+                headers: IDL.Vec(HeaderField),
+                body: IDL.Vec(IDL.Nat8)
+            });
+
+            const StreamingToken = IDL.Record({});
+
+            const StreamingCallbackHttpResponse = IDL.Record({
+                body: IDL.Vec(IDL.Nat8),
+                token: IDL.Opt(StreamingToken)
+            });
+
+            const StreamingStrategy = IDL.Variant({
+                Callback: IDL.Record({
+                    callback: IDL.Func(
+                        [StreamingToken],
+                        [StreamingCallbackHttpResponse],
+                        ['query']
+                    )
+                })
+            });
+
+            const HttpResponse = IDL.Record({
+                status_code: IDL.Nat16,
+                headers: IDL.Vec(HeaderField),
+                body: IDL.Vec(IDL.Nat8),
+                upgrade: IDL.Opt(IDL.Bool),
+                streaming_strategy: IDL.Opt(StreamingStrategy)
+            });
+
+            return IDL.Service({
+                http_request: IDL.Func(
+                    [HttpRequest],
+                    [HttpResponse],
+                    ['query']
+                ),
+                http_request_update: IDL.Func(
+                    [HttpUpdateRequest],
+                    [HttpResponse],
+                    []
+                )
+            });
+        },
+        {
+            agent,
+            canisterId
+        }
+    );
+}
+
+export interface _SERVICE {
+    http_request: ActorMethod<
+        [
+            {
+                url: string;
+                method: string;
+                body: Uint8Array | number[];
+                headers: Array<[string, string]>;
+                certificate_version: [] | [number];
+            }
+        ],
+        {
+            body: Uint8Array | number[];
+            headers: Array<[string, string]>;
+            upgrade: [] | [boolean];
+            streaming_strategy:
+                | []
+                | [
+                      {
+                          Callback: {
+                              token: Uint8Array | number[];
+                              callback: [Principal, string];
+                          };
+                      }
+                  ];
+            status_code: number;
+        }
+    >;
+    http_request_update: ActorMethod<
+        [
+            {
+                url: string;
+                method: string;
+                body: Uint8Array | number[];
+                headers: Array<[string, string]>;
+            }
+        ],
+        {
+            body: Uint8Array | number[];
+            headers: Array<[string, string]>;
+            upgrade: [] | [boolean];
+            streaming_strategy:
+                | []
+                | [
+                      {
+                          Callback: {
+                              token: Uint8Array | number[];
+                              callback: [Principal, string];
+                          };
+                      }
+                  ];
+            status_code: number;
+        }
+    >;
+}

package/src/experimental/lib/http_client/fetch_ic/agent.ts

@@ -0,0 +1,20 @@
+import { Agent, HttpAgent, Identity } from '@dfinity/agent';
+
+export async function createAgent(
+    identity: Identity,
+    host: string
+): Promise<Agent> {
+    const runningLocally =
+        host.includes(`localhost:`) || host.includes(`127.0.0.1:`);
+
+    const agent = new HttpAgent({
+        host,
+        identity
+    });
+
+    if (runningLocally === true) {
+        await agent.fetchRootKey();
+    }
+
+    return agent;
+}