[SavedObjects] Add zod support for schemas and modelVersions

src/core/packages/saved-objects/base-server-internal/src/model_version/backward_conversion_schema.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { schema } from '@kbn/config-schema';
+import { z } from '@kbn/zod';
 import { convertModelVersionBackwardConversionSchema } from './backward_conversion_schema';
 import type {
   SavedObjectUnsanitizedDoc,
@@ -24,6 +25,16 @@ describe('convertModelVersionBackwardConversionSchema', () => {
     ...parts,
   });
 
+  it('should throw if the schema is unknown', () => {
+    const mySchema = {} as any;
+
+    expect(() =>
+      convertModelVersionBackwardConversionSchema(mySchema)
+    ).toThrowErrorMatchingInlineSnapshot(
+      `"Unknown forward compatibility schema. Must be defined with \`@kbn/zod\` or \`@kbn/config-schema\`."`
+    );
+  });
+
   describe('using functions', () => {
     it('converts the schema', () => {
       const conversionSchema: jest.MockedFunction<SavedObjectModelVersionForwardCompatibilityFn> =
@@ -152,4 +163,71 @@ describe('convertModelVersionBackwardConversionSchema', () => {
       });
     });
   });
+
+  describe('using zod', () => {
+    it('converts the schema', () => {
+      const conversionSchema = z.object({
+        foo: z.string().optional(),
+      });
+      const parseSpy = jest.spyOn(conversionSchema, 'safeParse');
+
+      const doc = createDoc({ attributes: { foo: 'bar' } });
+      const converted = convertModelVersionBackwardConversionSchema(conversionSchema);
+
+      const output = converted(doc);
+
+      expect(parseSpy).toHaveBeenCalledTimes(1);
+      expect(parseSpy).toHaveBeenCalledWith({ foo: 'bar' });
+      expect(output).toEqual(doc);
+    });
+
+    it('returns the document with the updated properties', () => {
+      const conversionSchema = z.object({
+        foo: z.string().optional(),
+      });
+
+      const doc = createDoc({ attributes: { foo: 'bar', hello: 'dolly' } });
+      const converted = convertModelVersionBackwardConversionSchema(conversionSchema);
+
+      const output = converted(doc);
+
+      expect(output).toEqual({
+        ...doc,
+        attributes: {
+          foo: 'bar',
+        },
+      });
+    });
+
+    it('throws if the validation throws', () => {
+      const conversionSchema = z.object({
+        foo: z.string(),
+      });
+
+      const doc = createDoc({ attributes: { foo: 1 } });
+      const converted = convertModelVersionBackwardConversionSchema(conversionSchema);
+
+      expect(() => converted(doc)).toThrow(/Invalid input: expected string, received number/);
+    });
+
+    it('returns the known subset of keys with their original values', () => {
+      const conversionSchema = z.object({
+        durations: z.array(z.string()),
+        byteSize: z.string(),
+      });
+
+      const doc = createDoc({
+        attributes: { durations: ['1m', '4d'], byteSize: '1gb', excluded: true },
+      });
+      const converted = convertModelVersionBackwardConversionSchema(conversionSchema);
+
+      expect(converted(doc)).toEqual({
+        ...doc,
+        attributes: {
+          durations: ['1m', '4d'],
+          byteSize: '1gb',
+        },
+      });
+    });
+  });
 });

src/core/packages/saved-objects/base-server-internal/src/model_version/backward_conversion_schema.ts

@@ -7,29 +7,47 @@
  * License v3.0 only", or the "Server Side Public License, v 1".
  */
 
-import { isConfigSchema, type ObjectType } from '@kbn/config-schema';
+import { isZod, z } from '@kbn/zod';
+import { isConfigSchema } from '@kbn/config-schema';
 import type {
   SavedObjectUnsanitizedDoc,
   SavedObjectModelVersionForwardCompatibilitySchema,
 } from '@kbn/core-saved-objects-server';
 import { pickValuesBasedOnStructure } from '../utils';
 
-function isObjectType(
-  schema: SavedObjectModelVersionForwardCompatibilitySchema
-): schema is ObjectType {
-  return isConfigSchema(schema);
-}
-
 export type ConvertedSchema = (doc: SavedObjectUnsanitizedDoc) => SavedObjectUnsanitizedDoc;
 
+function toAttributeObject(attributes: unknown): object {
+  if (attributes !== null && typeof attributes === 'object') {
+    return attributes;
+  }
+  return {};
+}
+
 export const convertModelVersionBackwardConversionSchema = (
-  schema: SavedObjectModelVersionForwardCompatibilitySchema
+  forwardSchema: SavedObjectModelVersionForwardCompatibilitySchema
 ): ConvertedSchema => {
-  if (isObjectType(schema)) {
+  if (isZod(forwardSchema)) {
+    const zodSchema = forwardSchema;
+    return (doc) => {
+      const originalAttrs = toAttributeObject(doc.attributes);
+      const result = zodSchema.safeParse(doc.attributes);
+      if (!result.success) {
+        throw new Error(z.prettifyError(result.error));
+      }
+      const convertedAttrs = pickValuesBasedOnStructure(result.data, originalAttrs);
+      return {
+        ...doc,
+        attributes: convertedAttrs,
+      };
+    };
+  }
+
+  if (isConfigSchema(forwardSchema)) {
     return (doc) => {
-      const originalAttrs = doc.attributes as object;
+      const originalAttrs = toAttributeObject(doc.attributes);
       // Get the validated object, with possible stripping of unknown keys
-      const validatedAttrs = schema.validate(doc.attributes);
+      const validatedAttrs = forwardSchema.validate(doc.attributes);
       // Use the validated attrs object to pick values from the original attrs.
       //
       // If we reversed this, validation conversion would be returned in the
@@ -41,13 +59,19 @@ export const convertModelVersionBackwardConversionSchema = (
         attributes: convertedAttrs,
       };
     };
-  } else {
+  }
+
+  if (typeof forwardSchema === 'function') {
     return (doc) => {
-      const attrs = schema(doc.attributes);
+      const attrs = forwardSchema(doc.attributes);
       return {
         ...doc,
         attributes: attrs,
       };
     };
   }
+
+  throw new Error(
+    'Unknown forward compatibility schema. Must be defined with `@kbn/zod` or `@kbn/config-schema`.'
+  );
 };

src/core/packages/saved-objects/base-server-internal/src/validation/base_schema.ts

@@ -0,0 +1,95 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { z } from '@kbn/zod';
+import { schema, type Type } from '@kbn/config-schema';
+import type { SavedObjectSanitizedDoc } from '@kbn/core-saved-objects-server';
+
+// We convert `SavedObjectSanitizedDoc` to its validation schema representation
+// to ensure that we don't forget to keep the schema up-to-date. TS will complain
+// if we update `SavedObjectSanitizedDoc` without making changes below.
+type SavedObjectSanitizedDocSchema = {
+  [K in keyof Required<SavedObjectSanitizedDoc>]: Type<SavedObjectSanitizedDoc[K]>;
+};
+
+/**
+ * Base config-schema schema for a saved object.
+ *
+ * @internal
+ */
+export const baseConfigSchema = schema.object({
+  id: schema.string({ minLength: 1 }),
+  type: schema.string(),
+  references: schema.arrayOf(
+    schema.object({
+      name: schema.string(),
+      type: schema.string(),
+      id: schema.string(),
+    }),
+    { defaultValue: [], maxSize: 1000 }
+  ),
+  namespace: schema.maybe(schema.string()),
+  namespaces: schema.maybe(schema.arrayOf(schema.string(), { maxSize: 100 })),
+  migrationVersion: schema.maybe(schema.recordOf(schema.string(), schema.string())),
+  coreMigrationVersion: schema.maybe(schema.string()),
+  typeMigrationVersion: schema.maybe(schema.string()),
+  updated_at: schema.maybe(schema.string()),
+  updated_by: schema.maybe(schema.string()),
+  created_at: schema.maybe(schema.string()),
+  created_by: schema.maybe(schema.string()),
+  version: schema.maybe(schema.string()),
+  originId: schema.maybe(schema.string()),
+  managed: schema.maybe(schema.boolean()),
+  accessControl: schema.maybe(
+    schema.object({
+      owner: schema.string(),
+      accessMode: schema.oneOf([schema.literal('write_restricted'), schema.literal('default')]),
+    })
+  ),
+  attributes: schema.recordOf(schema.string(), schema.maybe(schema.any())),
+} satisfies SavedObjectSanitizedDocSchema);
+
+/**
+ * Base Zod schema for a saved object.
+ *
+ * @internal
+ */
+export const baseZodSchema = z.object({
+  id: z.string().min(1),
+  type: z.string(),
+  references: z
+    .array(
+      z.object({
+        name: z.string(),
+        type: z.string(),
+        id: z.string(),
+      })
+    )
+    .max(1000)
+    .default([]),
+  namespace: z.string().optional(),
+  namespaces: z.array(z.string()).max(100).optional(),
+  migrationVersion: z.record(z.string(), z.string()).optional(),
+  coreMigrationVersion: z.string().optional(),
+  typeMigrationVersion: z.string().optional(),
+  updated_at: z.string().optional(),
+  updated_by: z.string().optional(),
+  created_at: z.string().optional(),
+  created_by: z.string().optional(),
+  version: z.string().optional(),
+  originId: z.string().optional(),
+  managed: z.boolean().optional(),
+  accessControl: z
+    .object({
+      owner: z.string(),
+      accessMode: z.enum(['write_restricted', 'default']),
+    })
+    .optional(),
+  attributes: z.record(z.string(), z.any().optional()),
+}) satisfies z.ZodType<SavedObjectSanitizedDoc>;