@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/test/property/arbitraries/candid/reference/service_arb/definition_arb.ts

@@ -0,0 +1,163 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { IDL } from '#lib/index';
+
+import { UniqueIdentifierArb } from '../../../unique_identifier_arb';
+import {
+    CandidDefinition,
+    ServiceCandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import {
+    ServiceMethodArb,
+    ServiceMethodDefinition
+} from './service_method_arb';
+
+export function ServiceDefinitionArb(
+    fieldCandidDefArb: WithShapesArb<CandidDefinition>
+): WithShapesArb<ServiceCandidDefinition> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            fc.uniqueArray(ServiceMethodArb(fieldCandidDefArb), {
+                selector: (entry) => entry.definition.name
+            }),
+            fc.constant(true) // TODO This needs to be true, I don't know why we set up to be an arbitrary boolean if it has to be true
+        )
+        .map(
+            ([
+                name,
+                fieldsAndShapes,
+                useTypeDeclaration
+            ]): WithShapes<ServiceCandidDefinition> => {
+                const fields = fieldsAndShapes.map(
+                    (fieldAndShapes) => fieldAndShapes.definition
+                );
+                const recursiveShapes = fieldsAndShapes.reduce(
+                    (acc, fieldAndShapes) => {
+                        return { ...acc, ...fieldAndShapes.recursiveShapes };
+                    },
+                    {}
+                );
+
+                const typeAnnotation = generateCandidTypeAnnotation(
+                    useTypeDeclaration,
+                    name
+                );
+
+                const typeObject = generateTypeObject(
+                    useTypeDeclaration,
+                    name,
+                    fields
+                );
+
+                const runtimeTypeObject = generateRuntimeTypeObject(fields);
+
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(
+                        useTypeDeclaration,
+                        name,
+                        fields
+                    );
+
+                const imports = generateImports(fields);
+
+                return {
+                    definition: {
+                        name,
+                        candidMeta: {
+                            typeAnnotation,
+                            typeObject,
+                            runtimeTypeObject,
+                            variableAliasDeclarations,
+                            imports,
+                            candidType: 'Service'
+                        },
+                        funcs: fields
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+function generateImports(
+    serviceMethods: ServiceMethodDefinition[]
+): Set<string> {
+    const serviceImports = ['IDL'];
+    return new Set([
+        ...serviceMethods.flatMap((serviceMethod) =>
+            Array.from(serviceMethod.imports)
+        ),
+        'Principal',
+        'query',
+        ...serviceImports
+    ]);
+}
+
+function generateVariableAliasDeclarations(
+    useTypeDeclaration: boolean,
+    name: string,
+    serviceMethods: ServiceMethodDefinition[]
+): string[] {
+    const serviceMethodTypeAliasDecls = serviceMethods.flatMap(
+        (serviceMethod) => serviceMethod.variableAliasDeclarations
+    );
+    if (useTypeDeclaration === true) {
+        const type = [`type ${name} = Principal;`];
+        return [
+            ...serviceMethodTypeAliasDecls,
+            `const ${name} = ${generateTypeObject(
+                false,
+                name,
+                serviceMethods
+            )};`,
+            ...type
+        ];
+    }
+    return serviceMethodTypeAliasDecls;
+}
+
+function generateCandidTypeAnnotation(
+    useTypeDeclaration: boolean,
+    name: string
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    return '[Principal]';
+}
+
+function generateTypeObject(
+    useTypeDeclaration: boolean,
+    name: string,
+    serviceMethods: ServiceMethodDefinition[]
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    const methods = serviceMethods
+        .map((serviceMethod) => serviceMethod.idl)
+        .filter((typeDeclaration) => typeDeclaration)
+        .join(',\n');
+
+    return `IDL.Service({${methods}})`;
+}
+
+// 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 generateRuntimeTypeObject(serviceMethods: ServiceMethodDefinition[]) {
+    const methods = serviceMethods.reduce((acc, serviceMethod) => {
+        return {
+            ...acc,
+            [serviceMethod.name]: serviceMethod.runtimeTypeObject
+        };
+    }, {});
+
+    return IDL.Service(methods);
+}

package/src/experimental/test/property/arbitraries/candid/reference/service_arb/index.ts

@@ -0,0 +1,41 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+import fc from 'fast-check';
+
+import { Context } from '../../../types';
+import { candidDefinitionArb } from '../../candid_definition_arb';
+import {
+    CandidDefinition,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { CandidValueAndMeta } from '../../candid_value_and_meta_arb';
+import { CandidValueAndMetaArbGenerator } from '../../candid_value_and_meta_arb_generator';
+import { ServiceDefinitionArb } from './definition_arb';
+import { ServiceValueArb } from './values_arb';
+
+// TODO:
+// - services that are more than type-definitions, i.e. have functionality
+// - async service methods
+// - non-query methods
+// - actually using the service
+
+// Example Service:
+// const SomeService = Canister({
+//     method1: query([], Void),
+//     method2: query([text, text, nat64], nat64),
+// });
+
+export function ServiceArb(
+    context: Context,
+    innerCandidDefinitionArb: WithShapesArb<CandidDefinition> = candidDefinitionArb(
+        context,
+        {}
+    )
+): fc.Arbitrary<CandidValueAndMeta<Principal>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        ServiceDefinitionArb(innerCandidDefinitionArb),
+        ServiceValueArb
+    );
+}

package/src/experimental/test/property/arbitraries/candid/reference/service_arb/service_method_arb.ts

@@ -0,0 +1,110 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { toFuncArgs } from '#lib/func';
+import { IDL } from '#lib/index';
+
+import { JsPropertyNameArb } from '../../../js_name_arb';
+import {
+    CandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { VoidDefinitionArb } from '../../primitive/void_arb';
+
+type Mode = 'query' | 'update';
+
+export type ServiceMethodDefinition = {
+    name: string;
+    runtimeTypeObject: IDL.Type;
+    imports: Set<string>;
+    variableAliasDeclarations: string[];
+    src: string;
+    idl: string;
+};
+
+export function ServiceMethodArb(
+    candidDefArb: WithShapesArb<CandidDefinition>
+): WithShapesArb<ServiceMethodDefinition> {
+    return fc
+        .tuple(
+            JsPropertyNameArb,
+            fc.constantFrom<Mode>('query', 'update'),
+            fc.array(candidDefArb),
+            fc.oneof(candidDefArb, VoidDefinitionArb())
+        )
+        .map(
+            ([
+                name,
+                mode,
+                paramsAndShapes,
+                returnTypeAndShapes
+            ]): WithShapes<ServiceMethodDefinition> => {
+                const params = paramsAndShapes.map((thing) => thing.definition);
+                const returnType = returnTypeAndShapes.definition;
+                const recursiveShapes = paramsAndShapes.reduce((acc, thing) => {
+                    return { ...acc, ...thing.recursiveShapes };
+                }, returnTypeAndShapes.recursiveShapes);
+                const paramTypeObjects = params.map(
+                    (param) => param.candidMeta.typeObject
+                );
+
+                const variableAliasDeclarations = params.reduce(
+                    (
+                        acc,
+                        { candidMeta: { variableAliasDeclarations } }
+                    ): string[] => {
+                        return [...acc, ...variableAliasDeclarations];
+                    },
+                    returnType.candidMeta.variableAliasDeclarations
+                );
+
+                const src = `${name.startsWith('"') ? `"${name.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"` : name}: ${mode}([${paramTypeObjects}], ${returnType.candidMeta.typeObject})`;
+                const idl = `${name.startsWith('"') ? `"${name.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"` : name}: IDL.Func([${paramTypeObjects}], [${
+                    returnType.candidMeta.typeObject
+                }], ${mode === 'query' ? '["query"]' : 'undefined'})`;
+
+                const imports = params.reduce(
+                    (acc, param) => {
+                        return new Set([...acc, ...param.candidMeta.imports]);
+                    },
+                    new Set([mode, ...returnType.candidMeta.imports])
+                );
+
+                const runtimeTypeObject = generateRuntimeTypeObject(
+                    mode,
+                    params,
+                    returnType
+                );
+
+                return {
+                    definition: {
+                        name,
+                        runtimeTypeObject,
+                        imports,
+                        variableAliasDeclarations,
+                        src,
+                        idl
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+function generateRuntimeTypeObject(
+    mode: Mode,
+    params: CandidDefinition[],
+    returnType: CandidDefinition
+): IDL.Type {
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    const paramTypeObjects = params.map(
+        (param) => param.candidMeta.runtimeTypeObject ?? IDL.Empty
+    );
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    const returnTypeObject =
+        returnType.candidMeta.runtimeTypeObject ?? IDL.Empty;
+
+    return IDL.Func(toFuncArgs(paramTypeObjects), [returnTypeObject], [mode]);
+}

package/src/experimental/test/property/arbitraries/candid/reference/service_arb/values_arb.ts

@@ -0,0 +1,20 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+import fc from 'fast-check';
+
+import { CandidValues } from '../../candid_values_arb';
+import { PrincipalValueArb } from '../principal_arb';
+
+export function ServiceValueArb(): fc.Arbitrary<CandidValues<Principal>> {
+    return PrincipalValueArb().map((principal) => {
+        const valueLiteral = `${principal.valueLiteral}`;
+        const value = principal.agentArgumentValue;
+
+        return {
+            valueLiteral,
+            agentArgumentValue: value,
+            agentResponseValue: value
+        };
+    });
+}

package/src/experimental/test/property/arbitraries/candid/simple_type_arbs/candid_type_to_azle_candid_type.ts

@@ -0,0 +1,66 @@
+import '#experimental/build/assert_experimental';
+
+import { IDL } from '#lib/index';
+
+import { SimpleCandidType } from '../candid_type';
+
+export function candidTypeToRuntimeTypeObject(
+    candidType: SimpleCandidType
+): IDL.Type | undefined {
+    if (candidType === 'blob') {
+        return IDL.Vec(IDL.Nat8);
+    }
+    if (candidType === 'bool') {
+        return IDL.Bool;
+    }
+    if (candidType === 'float32') {
+        return IDL.Float32;
+    }
+    if (candidType === 'float64') {
+        return IDL.Float64;
+    }
+    if (candidType === 'int') {
+        return IDL.Int;
+    }
+    if (candidType === 'int8') {
+        return IDL.Int8;
+    }
+    if (candidType === 'int16') {
+        return IDL.Int16;
+    }
+    if (candidType === 'int32') {
+        return IDL.Int32;
+    }
+    if (candidType === 'int64') {
+        return IDL.Int64;
+    }
+    if (candidType === 'nat') {
+        return IDL.Nat;
+    }
+    if (candidType === 'nat8') {
+        return IDL.Nat8;
+    }
+    if (candidType === 'nat16') {
+        return IDL.Nat16;
+    }
+    if (candidType === 'nat32') {
+        return IDL.Nat32;
+    }
+    if (candidType === 'nat64') {
+        return IDL.Nat64;
+    }
+    if (candidType === 'Null') {
+        return IDL.Null;
+    }
+    if (candidType === 'text') {
+        return IDL.Text;
+    }
+    // TODO not sure we have landed on the best solution for representing void in this property testing framework
+    if (candidType === 'Void') {
+        return undefined;
+    }
+    if (candidType === 'Principal') {
+        return IDL.Principal;
+    }
+    throw new Error(`Unexpected SimpleCandidType: ${candidType}`);
+}

package/src/experimental/test/property/arbitraries/candid/simple_type_arbs/definition_arb.ts

@@ -0,0 +1,95 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { UniqueIdentifierArb } from '../../unique_identifier_arb';
+import {
+    PrimitiveDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../candid_definition_arb/types';
+import { SimpleCandidType, simpleCandidTypeToTsType } from '../candid_type';
+import { candidTypeToRuntimeTypeObject } from './candid_type_to_azle_candid_type';
+
+export function SimpleCandidDefinitionArb(
+    candidType: SimpleCandidType,
+    useVariableAliasDeclaration?: boolean
+): WithShapesArb<PrimitiveDefinition> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            useVariableAliasDeclarationArb(useVariableAliasDeclaration)
+        )
+        .map(
+            ([
+                name,
+                useTypeDeclarationChance
+            ]): WithShapes<PrimitiveDefinition> => {
+                const useTypeDeclaration =
+                    useTypeDeclarationChance && candidType !== 'Void';
+                const typeAnnotation = simpleCandidTypeToTsType(candidType);
+                const idl = toIDL(candidType);
+                const typeObject = useTypeDeclaration ? name : idl;
+                const runtimeTypeObject =
+                    candidTypeToRuntimeTypeObject(candidType);
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(
+                        name,
+                        candidType,
+                        useTypeDeclaration
+                    );
+                return {
+                    definition: {
+                        candidMeta: {
+                            typeAnnotation,
+                            typeObject,
+                            candidType,
+                            runtimeTypeObject,
+                            imports: generateImports(candidType),
+                            variableAliasDeclarations
+                        }
+                    },
+                    recursiveShapes: {}
+                };
+            }
+        );
+}
+
+function generateImports(candidType: SimpleCandidType): Set<string> {
+    if (candidType === 'Principal') {
+        return new Set(['IDL', 'Principal']);
+    }
+    return new Set(['IDL']);
+}
+
+function toIDL(candidType: SimpleCandidType): string {
+    if (candidType === 'Void') {
+        return '';
+    }
+    if (candidType === 'blob') {
+        return 'IDL.Vec(IDL.Nat8)';
+    }
+    return `IDL.${candidType.charAt(0).toUpperCase()}${candidType.slice(1)}`;
+}
+
+function useVariableAliasDeclarationArb(
+    useVariableAliasDeclaration: boolean | undefined
+): fc.Arbitrary<boolean> {
+    return useVariableAliasDeclaration === undefined
+        ? fc.boolean()
+        : fc.constant(useVariableAliasDeclaration);
+}
+
+function generateVariableAliasDeclarations(
+    name: string,
+    candidType: SimpleCandidType,
+    useTypeDeclaration: boolean
+): string[] {
+    if (useTypeDeclaration === true) {
+        return [
+            `const ${name} = ${toIDL(candidType)};`,
+            `type ${name} = ${simpleCandidTypeToTsType(candidType)};`
+        ];
+    }
+    return [];
+}

package/src/experimental/test/property/arbitraries/candid/simple_type_arbs/values_arb.ts

@@ -0,0 +1,19 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { CandidValues } from '../candid_values_arb';
+import { CorrespondingJSType } from '../corresponding_js_type';
+
+export function SimpleCandidValuesArb<T extends CorrespondingJSType>(
+    arb: fc.Arbitrary<T>,
+    toLiteral: (value: T) => string
+): fc.Arbitrary<CandidValues<T>> {
+    return arb.map((value): CandidValues<T> => {
+        return {
+            valueLiteral: toLiteral(value),
+            agentArgumentValue: value,
+            agentResponseValue: value
+        };
+    });
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/bigint.ts

@@ -0,0 +1,5 @@
+import '#experimental/build/assert_experimental';
+
+export function bigintToSrcLiteral(value: bigint): string {
+    return `${value.toString()}n`;
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/blob.ts

@@ -0,0 +1,5 @@
+import '#experimental/build/assert_experimental';
+
+export function blobToSrcLiteral(value: Uint8Array): string {
+    return `new Uint8Array([${[...value].join(', ')}])`;
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/boolean.ts

@@ -0,0 +1,5 @@
+import '#experimental/build/assert_experimental';
+
+export function booleanToSrcLiteral(value: boolean): string {
+    return value.toString();
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/float.ts

@@ -0,0 +1,18 @@
+import '#experimental/build/assert_experimental';
+
+export function floatToSrcLiteral(value: number): string {
+    if (Number.isNaN(value)) {
+        return 'Number.NaN';
+    }
+    if (Number.isFinite(value)) {
+        if (value === 0 && 1 / value === -Infinity) {
+            return '-0';
+        }
+
+        return value.toString();
+    }
+    if (value > 0) {
+        return 'Number.POSITIVE_INFINITY';
+    }
+    return 'Number.NEGATIVE_INFINITY';
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/null.ts

@@ -0,0 +1,5 @@
+import '#experimental/build/assert_experimental';
+
+export function nullToSrcLiteral(_value: null): string {
+    return 'null';
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/number.ts

@@ -0,0 +1,5 @@
+import '#experimental/build/assert_experimental';
+
+export function numberToSrcLiteral(value: number): string {
+    return value.toString();
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/principal.ts

@@ -0,0 +1,7 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+
+export function principalToSrcLiteral(value: Principal): string {
+    return `Principal.fromText('${value.toText()}')`;
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/string.ts

@@ -0,0 +1,12 @@
+import '#experimental/build/assert_experimental';
+
+function escapeStringForJavaScript(input: string): string {
+    return input
+        .replace(/\\/g, '\\\\') // Escape backslashes
+        .replace(/'/g, "\\'") // Escape single quotes
+        .replace(/"/g, '\\"'); // Escape double quotes
+}
+
+export function stringToSrcLiteral(value: string): string {
+    return `'${escapeStringForJavaScript(value)}'`;
+}

package/src/experimental/test/property/arbitraries/candid/to_src_literal/void.ts

@@ -0,0 +1,5 @@
+import '#experimental/build/assert_experimental';
+
+export function voidToSrcLiteral(): string {
+    return 'undefined';
+}