fix(js): Compatibility with cfworker env

js/core/package.json

@@ -29,22 +29,21 @@
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-async-hooks": "~1.25.0",
     "@opentelemetry/core": "~1.25.0",
+    "@opentelemetry/exporter-jaeger": "^1.25.0",
     "@opentelemetry/sdk-metrics": "~1.25.0",
     "@opentelemetry/sdk-node": "^0.52.0",
     "@opentelemetry/sdk-trace-base": "~1.25.0",
-    "@opentelemetry/exporter-jaeger": "^1.25.0",
     "@types/json-schema": "^7.0.15",
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "async-mutex": "^0.5.0",
-    "body-parser": "^1.20.3",
     "cors": "^2.8.5",
+    "dotprompt": "^1.1.1",
     "express": "^4.21.0",
     "get-port": "^5.1.0",
     "json-schema": "^0.4.0",
     "zod": "^3.23.8",
-    "zod-to-json-schema": "^3.22.4",
-    "dotprompt": "^1.1.1"
+    "zod-to-json-schema": "^3.22.4"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
@@ -57,6 +56,7 @@
     "typescript": "^4.9.0"
   },
   "optionalDependencies": {
+    "@cfworker/json-schema": "^4.1.1",
     "@genkit-ai/firebase": "^1.16.1"
   },
   "types": "lib/index.d.ts",

js/core/src/index.ts

@@ -77,7 +77,12 @@ export {
 } from './flow.js';
 export * from './plugin.js';
 export * from './reflection.js';
-export { defineJsonSchema, defineSchema, type JSONSchema } from './schema.js';
+export {
+  defineJsonSchema,
+  defineSchema,
+  disableSchemaCodeGeneration,
+  type JSONSchema,
+} from './schema.js';
 export * from './telemetryTypes.js';
 export * from './utils.js';
 

js/core/src/reflection.ts

@@ -128,6 +128,13 @@ export class ReflectionServer {
    * The server will be registered to be shut down on process exit.
    */
   async start() {
+    if (global[SCHEMA_VALIDATION_MODE] === 'interpret') {
+      logger.debug(
+        'Skipping ReflectionServer start: not supported in interpret mode.'
+      );
+      return;
+    }
+
     const server = express();
 
     server.use(express.json({ limit: this.options.bodyLimit }));

js/core/src/schema.ts

@@ -14,15 +14,36 @@
  * limitations under the License.
  */
 
+import { Validator } from '@cfworker/json-schema';
 import Ajv, { type ErrorObject, type JSONSchemaType } from 'ajv';
 import addFormats from 'ajv-formats';
 import { z } from 'zod';
 import zodToJsonSchema from 'zod-to-json-schema';
 import { GenkitError } from './error.js';
+import { logger } from './logging.js';
 import type { Registry } from './registry.js';
 const ajv = new Ajv();
 addFormats(ajv);
 
+export const SCHEMA_VALIDATION_MODE = 'schemaValidationMode' as const;
+
+/**
+ * Disable schema code generation in runtime. Use this if your runtime
+ * environment restricts the use of `eval` or `new Function`, for e.g., in
+ * CloudFlare workers.
+ */
+export function disableSchemaCodeGeneration() {
+  logger.warn(
+    "It looks like you're trying to disable schema code generation. Please ensure that the '@cfworker/json-schema' package is installed: `npm i --save @cfworker/json-schema`"
+  );
+  global[SCHEMA_VALIDATION_MODE] = 'interpret';
+}
+
+/** Visible for testing */
+export function resetSchemaCodeGeneration() {
+  global[SCHEMA_VALIDATION_MODE] = undefined;
+}
+
 export { z }; // provide a consistent zod to use throughout genkit
 
 /**
@@ -32,6 +53,7 @@ export type JSONSchema = JSONSchemaType<any> | any;
 
 const jsonSchemas = new WeakMap<z.ZodTypeAny, JSONSchema>();
 const validators = new WeakMap<JSONSchema, ReturnType<typeof ajv.compile>>();
+const cfWorkerValidators = new WeakMap<JSONSchema, Validator>();
 
 /**
  * Wrapper object for various ways schema can be provided.
@@ -97,6 +119,19 @@ function toErrorDetail(error: ErrorObject): ValidationErrorDetail {
   };
 }
 
+function cfWorkerErrorToValidationErrorDetail(error: {
+  instanceLocation: string;
+  error: string;
+}): ValidationErrorDetail {
+  const path = error.instanceLocation.startsWith('#/')
+    ? error.instanceLocation.substring(2)
+    : '';
+  return {
+    path: path.replace(/\//g, '.') || '(root)',
+    message: error.error,
+  };
+}
+
 /**
  * Validation response.
  */
@@ -115,6 +150,24 @@ export function validateSchema(
   if (!toValidate) {
     return { valid: true, schema: toValidate };
   }
+  const validationMode = (global[SCHEMA_VALIDATION_MODE] ?? 'compile') as
+    | 'compile'
+    | 'interpret';
+
+  if (validationMode === 'interpret') {
+    let validator = cfWorkerValidators.get(toValidate);
+    if (!validator) {
+      validator = new Validator(toValidate);
+      cfWorkerValidators.set(toValidate, validator);
+    }
+    const result = validator.validate(sanitizeForJsonSchema(data));
+    return {
+      valid: result.valid,
+      errors: result.errors?.map(cfWorkerErrorToValidationErrorDetail),
+      schema: toValidate,
+    };
+  }
+
   const validator = validators.get(toValidate) || ajv.compile(toValidate);
   const valid = validator(data) as boolean;
   const errors = validator.errors?.map((e) => e);
@@ -162,3 +215,18 @@ export function defineJsonSchema(
   registry.registerSchema(name, { jsonSchema });
   return jsonSchema;
 }
+
+function sanitizeForJsonSchema(data: any): any {
+  if (Array.isArray(data)) {
+    return data.map(sanitizeForJsonSchema);
+  } else if (data !== null && typeof data === 'object') {
+    const out: any = {};
+    for (const key in data) {
+      if (data[key] !== undefined) {
+        out[key] = sanitizeForJsonSchema(data[key]);
+      }
+    }
+    return out;
+  }
+  return data;
+}

js/core/tests/schema_test.ts

@@ -14,12 +14,15 @@
  * limitations under the License.
  */
 
+import Ajv from 'ajv';
 import * as assert from 'assert';
-import { describe, it } from 'node:test';
+import { describe, it, mock } from 'node:test';
 
 import {
   ValidationError,
+  disableSchemaCodeGeneration,
   parseSchema,
+  resetSchemaCodeGeneration,
   toJsonSchema,
   validateSchema,
   z,
@@ -162,3 +165,87 @@ describe('toJsonSchema', () => {
     );
   });
 });
+
+describe('disableSchemaCodeGeneration()', () => {
+  it('should validate using cfworker validator', () => {
+    const compileMock = mock.method(Ajv.prototype, 'compile');
+
+    disableSchemaCodeGeneration();
+    const result = validateSchema(
+      { foo: 123 },
+      {
+        jsonSchema: {
+          type: 'object',
+          properties: { foo: { type: 'boolean' } },
+        },
+      }
+    );
+
+    assert.strictEqual(result.valid, false);
+    const errorAtFoo = result.errors?.find((e) => e.path === 'foo');
+    assert.ok(errorAtFoo, 'Should have error at foo');
+    assert.strictEqual(compileMock.mock.callCount(), 0);
+    compileMock.mock.restore();
+    resetSchemaCodeGeneration();
+  });
+
+  it('should strip undefined values before validating', () => {
+    disableSchemaCodeGeneration();
+    const result = validateSchema(
+      { foo: 'hello', bar: undefined },
+      {
+        jsonSchema: {
+          type: 'object',
+          properties: { foo: { type: 'string' }, bar: { type: 'string' } },
+          required: ['foo'],
+        },
+      }
+    );
+    assert.strictEqual(result.valid, true);
+    resetSchemaCodeGeneration();
+  });
+
+  it('should strip undefined values recursively', () => {
+    disableSchemaCodeGeneration();
+    const result = validateSchema(
+      { wrapper: { inner: 'hello', ignored: undefined } },
+      {
+        jsonSchema: {
+          type: 'object',
+          properties: {
+            wrapper: {
+              type: 'object',
+              properties: { inner: { type: 'string' } },
+            },
+          },
+        },
+      }
+    );
+    assert.strictEqual(result.valid, true);
+    resetSchemaCodeGeneration();
+  });
+
+  it('should strip undefined values in objects inside arrays', () => {
+    disableSchemaCodeGeneration();
+    const result = validateSchema(
+      { items: [{ name: 'item1', desc: undefined }, { name: 'item2' }] },
+      {
+        jsonSchema: {
+          type: 'object',
+          properties: {
+            items: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name'],
+              },
+            },
+          },
+        },
+      }
+    );
+    assert.strictEqual(result.valid, true);
+    resetSchemaCodeGeneration();
+  });
+});

js/genkit/src/common.ts

@@ -129,6 +129,7 @@ export {
   UserFacingError,
   defineJsonSchema,
   defineSchema,
+  disableSchemaCodeGeneration,
   getClientHeader,
   getCurrentEnv,
   getStreamingCallback,