feat(cli-tools): generate dev custom functions

packages/cli-tools/package.json

@@ -49,6 +49,7 @@
     "@dfinity/utils": "^4.1",
     "@junobuild/cdn": "^2.3",
     "@junobuild/config": "^2.7",
+    "@junobuild/did-tools": "^0.3.10",
     "@junobuild/storage": "^2.3",
     "esbuild": "^0.27.0",
     "ora": "^9"

packages/cli-tools/src/commands/build.ts

@@ -27,16 +27,13 @@ import {rm} from 'node:fs/promises';
  */
 export const buildFunctions = async ({
   infile,
-  outfile,
   banner
 }: {
   infile: string;
-  outfile: string;
   banner?: {[type: string]: string};
-}): Promise<Omit<EsbuildResult, 'outputFiles'>> => {
-  const {outputFiles: _, ...rest} = await esbuild({
+}): Promise<EsbuildResult> =>
+  await esbuild({
     infile,
-    outfile,
     platform: 'browser',
     treeShaking: true,
     define: {
@@ -45,9 +42,6 @@ export const buildFunctions = async ({
     banner
   });
 
-  return rest;
-};
-
 /**
  * Builds a script using `esbuild` for `juno run`.
  *

packages/cli-tools/src/commands/generate.ts

@@ -0,0 +1,120 @@
+import {isNullish} from '@dfinity/utils';
+import {generateFunctions} from '@junobuild/did-tools';
+import type {Metafile} from 'esbuild';
+import {writeFile} from 'node:fs/promises';
+import {buildFunctions} from './build';
+
+export interface GenerateArgs {
+  infile: string;
+  outfileJs: string;
+  outfileRs: string;
+  banner?: {[type: string]: string};
+}
+
+export interface GenerateResultData {
+  version: string;
+  output: [string, Metafile['outputs'][0]];
+}
+
+type GenerateBuildResultData = GenerateResultData & {code: Uint8Array};
+
+export interface GenerateResultError {
+  status: 'error';
+  warnings?: string[];
+  errors: string[];
+}
+
+export type GenerateResult = {status: 'success'; result: GenerateResultData} | GenerateResultError;
+
+export type GenerateCodeResult =
+  | {status: 'success'; result: GenerateBuildResultData}
+  | GenerateResultError;
+
+export const buildAndGenerateFunctions = async ({
+  outfileJs,
+  outfileRs,
+  ...args
+}: GenerateArgs): Promise<GenerateResult> => {
+  const build = await buildWithEsbuild(args);
+
+  if (build.status === 'error') {
+    return build;
+  }
+
+  const {
+    result: {code, ...buildResult}
+  } = build;
+
+  // We generate the custom functions before the JavaScript script because
+  // there might be none, therefore no Rust module to generate but, also because
+  // the Docker image currently watches the script to initiate new automatic build.
+  await writeDevFunctions({code, outfileRs});
+
+  await writeDevScript({code, outfileJs});
+
+  return {status: 'success', result: buildResult};
+};
+
+const buildWithEsbuild = async ({
+  infile,
+  banner
+}: Omit<GenerateArgs, 'outfileJs' | 'outfileRs'>): Promise<GenerateCodeResult> => {
+  const {
+    metafile,
+    errors: buildErrors,
+    warnings: buildWarnings,
+    version,
+    outputFiles
+  } = await buildFunctions({
+    infile,
+    banner
+  });
+
+  const warnings = buildWarnings.map(({text}) => text);
+  const errors = buildErrors.map(({text}) => text);
+
+  if (errors.length > 0) {
+    return {status: 'error', errors, warnings};
+  }
+
+  const entry = Object.entries(metafile.outputs);
+
+  if (entry.length === 0) {
+    return {
+      status: 'error',
+      errors: ['Unexpected: No metafile resulting from the build was found.']
+    };
+  }
+
+  const code = outputFiles?.[0]?.contents;
+
+  if (isNullish(code)) {
+    return {
+      status: 'error',
+      errors: ['Unexpected: No script build for the functions.']
+    };
+  }
+
+  return {
+    status: 'success',
+    result: {
+      output: entry[0],
+      version,
+      code
+    }
+  };
+};
+
+const writeDevFunctions = async ({
+  code,
+  outfileRs
+}: Pick<GenerateBuildResultData, 'code'> & Pick<GenerateArgs, 'outfileRs'>) => {
+  await generateFunctions({code, outputFile: outfileRs});
+};
+
+const writeDevScript = async ({
+  code,
+  outfileJs
+}: Pick<GenerateBuildResultData, 'code'> & Pick<GenerateArgs, 'outfileJs'>) => {
+  await writeFile(outfileJs, code);
+};

packages/cli-tools/src/index.ts

@@ -1,5 +1,6 @@
 export * from './commands/build';
 export * from './commands/deploy';
+export * from './commands/generate';
 export * from './commands/publish';
 export * from './constants/deploy.constants';
 export type * from './types/deploy';

packages/did-tools/package.json

@@ -54,6 +54,7 @@
     "@babel/types": "7.28.4",
     "@dfinity/utils": "^4.1",
     "@dfinity/zod-schemas": "^3.1.0",
+    "@junobuild/functions": "^0.5.6",
     "zod": "^4"
   }
 }

packages/did-tools/src/functions/index.ts

@@ -0,0 +1,65 @@
+import type {Query, Update} from '@junobuild/functions';
+import {writeFile} from 'node:fs/promises';
+import {parseFunctions} from './services/parser.services';
+
+export interface GenerateArgs {
+  outputFile: string;
+  code: Uint8Array;
+}
+
+export const generateFunctions = async ({code, outputFile}: GenerateArgs) => {
+  const originalConsole = globalThis.console;
+  const originalRandom = globalThis.Math.random;
+
+  try {
+    // @junobuild/functions replaces globalThis.console with a version that calls
+    // __ic_cdk_print, which only exists in the WASM host environment. We stub it
+    // so the import doesn't throw when the module is evaluated in Node.
+    globalThis.__ic_cdk_print = (msg: string) => process.stdout.write(`${msg}\n`);
+
+    // It might be needed
+    // globalThis.__juno_satellite_random = () => {
+    //   const buf = new Uint32Array(1);
+    //   crypto.getRandomValues(buf);
+    //   return buf[0];
+    // };
+
+    const devModule = await import(
+      `data:text/javascript;base64,${Buffer.from(code).toString(`base64`)}`
+    );
+
+    // Lazy load the functions this way it uses the globalThis stubs we defined above
+    const {QuerySchema, UpdateSchema} = await import('@junobuild/functions');
+
+    const [queries, updates] = Object.entries(devModule).reduce<
+      [[string, Query][], [string, Update][]]
+    >(
+      ([queries, updates], entry) => {
+        const [key, value] = entry;
+
+        const config = typeof value === 'function' ? value({}) : value;
+
+        const query = QuerySchema.safeParse(config);
+        const update = UpdateSchema.safeParse(config);
+
+        return [
+          [...queries, ...(query.success ? [[key, query.data] as [string, Query]] : [])],
+          [...updates, ...(update.success ? [[key, update.data] as [string, Update]] : [])]
+        ];
+      },
+      [[], []]
+    );
+
+    // No custom functions to generate
+    if (queries.length === 0 && updates.length === 0) {
+      return;
+    }
+
+    const functions = parseFunctions({queries, updates});
+
+    await writeFile(outputFile, functions, 'utf-8');
+  } finally {
+    globalThis.console = originalConsole;
+    globalThis.Math.random = originalRandom;
+  }
+};