feat: Added option provide a zod schema instead of json schema

Author: kevinwang5658

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta27",
+  "version": "1.0.182-beta31",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -26,7 +26,8 @@
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "zod": "4.1.13"
   },
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.2",

package.json

@@ -7,6 +7,7 @@ import { spy } from 'sinon';
 import { ResourceSettings } from '../resource/resource-settings.js';
 import { TestConfig, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { getPty } from '../pty/index.js';
+import { z } from 'zod';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -170,6 +171,36 @@ describe('Plugin tests', () => {
     })
   })
 
+  it('Can get resource info (zod schema)', async () => {
+    const schema = z
+      .object({
+        plugins: z
+          .array(z.string())
+          .describe(
+            'Asdf plugins to install. See: https://github.com/asdf-community for a full list'
+          )
+      })
+      .strict()
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'typeId',
+          operatingSystems: [OS.Darwin],
+          schema,
+        }
+      }
+    }
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const resourceInfo = await testPlugin.getResourceInfo({ type: 'typeId' })
+    expect(resourceInfo.import).toMatchObject({
+      requiredParameters: [
+        'plugins'
+      ]
+    })
+  })
+
   it('Get resource info to default import to the one specified in the resource settings', async () => {
     const schema = {
       '$schema': 'http://json-schema.org/draft-07/schema',

src/plugin/plugin.test.ts

@@ -89,7 +89,7 @@ export class Plugin {
 
     const resource = this.resourceControllers.get(data.type)!;
 
-    const schema = resource.settings.schema as JSONSchemaType<any> | undefined;
+    const schema = resource.parsedSettings.schema as JSONSchemaType<any> | undefined;
     const requiredPropertyNames = (
       resource.settings.importAndDestroy?.requiredParameters
       ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)

src/plugin/plugin.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { ResourceSettings } from './resource-settings.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { TestConfig } from '../utils/test-utils.test.js';
+import { z } from 'zod';
+import { OS } from 'codify-schemas';
 
 describe('Resource options parser tests', () => {
   it('Parses default values from options', () => {
@@ -159,4 +161,26 @@ describe('Resource options parser tests', () => {
 
     expect(() => new ParsedResourceSettings(option)).toThrowError()
   })
+
+  it('Can handle a zod schema', () => {
+
+    const schema = z.object({
+      propA: z.string(),
+      repository: z.string(),
+    })
+
+    const option: ResourceSettings<z.infer<typeof schema>> = {
+      id: 'typeId',
+      operatingSystems: [OS.Darwin],
+      schema,
+      importAndDestroy: {
+        defaultRefreshValues: {
+          repository: 'abc'
+        }
+      }
+    }
+
+    console.log(new ParsedResourceSettings(option))
+
+  })
 })

src/resource/parsed-resource-settings.test.ts

@@ -1,18 +1,19 @@
 import { JSONSchemaType } from 'ajv';
 import { OS, StringIndexedObject } from 'codify-schemas';
+import { ZodObject, z } from 'zod';
 
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import {
   ArrayParameterSetting,
   DefaultParameterSetting,
   InputTransformation,
   ParameterSetting,
+  ResourceSettings,
+  StatefulParameterSetting,
   resolveElementEqualsFn,
   resolveEqualsFn,
   resolveMatcher,
-  resolveParameterTransformFn,
-  ResourceSettings,
-  StatefulParameterSetting
+  resolveParameterTransformFn
 } from './resource-settings.js';
 
 export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
@@ -29,18 +30,21 @@ export type ParsedArrayParameterSetting = {
 
 export type ParsedParameterSetting =
   {
-  isEqual: (desired: unknown, current: unknown) => boolean;
+    isEqual: (desired: unknown, current: unknown) => boolean;
   } & (DefaultParameterSetting
   | ParsedArrayParameterSetting
   | ParsedStatefulParameterSetting)
 
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
   private cache = new Map<string, unknown>();
   id!: string;
+  description?: string;
+
   schema?: Partial<JSONSchemaType<T | any>>;
   allowMultiple?: {
+    identifyingParameters?: string[];
     matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
-    requiredParameters?: string[]
+    findAllParameters?: () => Promise<Array<Partial<T>>>
   } | boolean;
 
   removeStatefulParametersBeforeDestroy?: boolean | undefined;
@@ -54,10 +58,22 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
 
   constructor(settings: ResourceSettings<T>) {
     this.settings = settings;
+    const { parameterSettings, schema, ...rest } = settings;
 
-    const { parameterSettings, ...rest } = settings;
     Object.assign(this, rest);
 
+    if (schema) {
+      this.schema = schema instanceof ZodObject
+        ? z.toJSONSchema(schema.strict(), {
+          target: 'draft-7',
+          override(ctx) {
+            ctx.jsonSchema.title = settings.id;
+            ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+          }
+        }) as JSONSchemaType<T>
+        : schema;
+    }
+
     this.validateSettings();
   }
 
@@ -199,7 +215,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`)
     }
 
-    const schema = this.settings.schema as JSONSchemaType<any>;
+    const schema = this.schema as JSONSchemaType<any>;
     if (!this.settings.importAndDestroy && (schema?.oneOf
         && Array.isArray(schema.oneOf)
         && schema.oneOf.some((s) => s.required)

src/resource/parsed-resource-settings.ts

@@ -11,6 +11,7 @@ import { tildify, untildify } from '../utils/functions.js';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { Plan } from '../plan/plan.js';
 import os from 'node:os';
+import { z } from 'zod';
 
 describe('Resource tests', () => {
 
@@ -952,4 +953,129 @@ describe('Resource tests', () => {
 
     process.env = oldProcessEnv;
   })
+
+  it('Can import and return all of the imported parameters (zod schema)', async () => {
+    const schema = z.object({
+      path: z
+        .string()
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      paths: z
+        .array(z.string())
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      prepend: z
+        .boolean()
+        .describe(
+          'Whether to prepend the paths to the PATH environment variable'
+        ),
+      declarationsOnly: z
+        .boolean()
+        .describe(
+          'Whether to only declare the paths in the PATH environment variable'
+        ),
+    })
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          schema,
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'directory' },
+            paths: { canModify: true, type: 'array', itemType: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshMapper: (input, context) => {
+              if (Object.keys(input).length === 0) {
+                return { paths: [], declarationsOnly: true };
+              }
+
+              return input;
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          paths: [
+            `${os.homedir()}/.pyenv/bin`,
+            `${os.homedir()}/.bun/bin`,
+            `${os.homedir()}/.deno/bin`,
+            `${os.homedir()}/.jenv/bin`,
+            `${os.homedir()}/a/random/path`,
+            `${os.homedir()}/.nvm/.bin/2`,
+            `${os.homedir()}/.nvm/.bin/3`
+          ]
+        }
+      }
+    }
+
+    const oldProcessEnv = structuredClone(process.env);
+
+    process.env['PYENV_ROOT'] = `${os.homedir()}/.pyenv`
+    process.env['BUN_INSTALL'] = `${os.homedir()}/.bun`
+    process.env['DENO_INSTALL'] = `${os.homedir()}/.deno`
+    process.env['JENV'] = `${os.homedir()}/.jenv`
+    process.env['NVM_DIR'] = `${os.homedir()}/.nvm`
+
+    const controller = new ResourceController(resource);
+    const importResult1 = await controller.import({ type: 'path' }, {});
+    expect(importResult1).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    const importResult2 = await controller.import({ type: 'path' }, { paths: ['$PYENV_ROOT/bin', '$BUN_INSTALL/bin'] });
+    expect(importResult2).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    process.env = oldProcessEnv;
+  })
 });

src/resource/resource-controller.test.ts

@@ -36,18 +36,17 @@ export class ResourceController<T extends StringIndexedObject> {
 
     this.typeId = this.settings.id;
     this.dependencies = this.settings.dependencies ?? [];
+    this.parsedSettings = new ParsedResourceSettings<T>(this.settings);
 
-    if (this.settings.schema) {
+    if (this.parsedSettings.schema) {
       this.ajv = new Ajv({
         allErrors: true,
         strict: true,
         strictRequired: false,
         allowUnionTypes: true
       })
-      this.schemaValidator = this.ajv.compile(this.settings.schema);
+      this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
     }
-
-    this.parsedSettings = new ParsedResourceSettings<T>(this.settings);
   }
 
   async initialize(): Promise<void> {
@@ -526,8 +525,8 @@ ${JSON.stringify(refresh, null, 2)}
   }
 
   private getAllParameterKeys(): string[] {
-    return this.settings.schema
-      ? Object.keys((this.settings.schema as any)?.properties)
+    return this.parsedSettings.schema
+      ? Object.keys((this.parsedSettings.schema as any)?.properties)
       : Object.keys(this.parsedSettings.parameterSettings);
   }