librechat-data-provider 0.7.4 → 0.7.7

package/src/utils.ts

@@ -0,0 +1,44 @@
+export const envVarRegex = /^\${(.+)}$/;
+
+/** Extracts the value of an environment variable from a string. */
+export function extractEnvVariable(value: string) {
+  if (!value) {
+    return value;
+  }
+
+  // Trim the input
+  const trimmed = value.trim();
+
+  // Special case: if it's just a single environment variable
+  const singleMatch = trimmed.match(envVarRegex);
+  if (singleMatch) {
+    const varName = singleMatch[1];
+    return process.env[varName] || trimmed;
+  }
+
+  // For multiple variables, process them using a regex loop
+  const regex = /\${([^}]+)}/g;
+  let result = trimmed;
+
+  // First collect all matches and their positions
+  const matches = [];
+  let match;
+  while ((match = regex.exec(trimmed)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      varName: match[1],
+      index: match.index,
+    });
+  }
+
+  // Process matches in reverse order to avoid position shifts
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const { fullMatch, varName, index } = matches[i];
+    const envValue = process.env[varName] || fullMatch;
+
+    // Replace at exact position
+    result = result.substring(0, index) + envValue + result.substring(index + fullMatch.length);
+  }
+
+  return result;
+}

package/src/zod.spec.ts

@@ -0,0 +1,526 @@
+/* eslint-disable jest/no-conditional-expect */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// zod.spec.ts
+import { z } from 'zod';
+import { convertJsonSchemaToZod } from './zod';
+import type { JsonSchemaType } from './zod';
+
+describe('convertJsonSchemaToZod', () => {
+  describe('primitive types', () => {
+    it('should convert string schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'string',
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse('test')).toBe('test');
+      expect(() => zodSchema?.parse(123)).toThrow();
+    });
+
+    it('should convert string enum schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'string',
+        enum: ['foo', 'bar', 'baz'],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse('foo')).toBe('foo');
+      expect(() => zodSchema?.parse('invalid')).toThrow();
+    });
+
+    it('should convert number schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'number',
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse(123)).toBe(123);
+      expect(() => zodSchema?.parse('123')).toThrow();
+    });
+
+    it('should convert boolean schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'boolean',
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse(true)).toBe(true);
+      expect(() => zodSchema?.parse('true')).toThrow();
+    });
+  });
+
+  describe('array types', () => {
+    it('should convert array of strings schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'array',
+        items: { type: 'string' },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse(['a', 'b', 'c'])).toEqual(['a', 'b', 'c']);
+      expect(() => zodSchema?.parse(['a', 123, 'c'])).toThrow();
+    });
+
+    it('should convert array of numbers schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'array',
+        items: { type: 'number' },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse([1, 2, 3])).toEqual([1, 2, 3]);
+      expect(() => zodSchema?.parse([1, '2', 3])).toThrow();
+    });
+  });
+
+  describe('object types', () => {
+    it('should convert simple object schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse({ name: 'John', age: 30 })).toEqual({ name: 'John', age: 30 });
+      expect(() => zodSchema?.parse({ name: 123, age: 30 })).toThrow();
+    });
+
+    it('should handle required fields', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+        required: ['name'],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse({ name: 'John' })).toEqual({ name: 'John' });
+      expect(() => zodSchema?.parse({})).toThrow();
+    });
+
+    it('should handle nested objects', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          user: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              age: { type: 'number' },
+            },
+            required: ['name'],
+          },
+        },
+        required: ['user'],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse({ user: { name: 'John', age: 30 } })).toEqual({
+        user: { name: 'John', age: 30 },
+      });
+      expect(() => zodSchema?.parse({ user: { age: 30 } })).toThrow();
+    });
+
+    it('should handle objects with arrays', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          names: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse({ names: ['John', 'Jane'] })).toEqual({ names: ['John', 'Jane'] });
+      expect(() => zodSchema?.parse({ names: ['John', 123] })).toThrow();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty object schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {},
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse({})).toEqual({});
+    });
+
+    it('should handle unknown types as unknown', () => {
+      const schema = {
+        type: 'invalid',
+      } as unknown as JsonSchemaType;
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse('anything')).toBe('anything');
+      expect(zodSchema?.parse(123)).toBe(123);
+    });
+
+    it('should handle empty enum arrays as regular strings', () => {
+      const schema: JsonSchemaType = {
+        type: 'string',
+        enum: [],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema?.parse('test')).toBe('test');
+    });
+  });
+
+  describe('complex schemas', () => {
+    it('should handle complex nested schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          id: { type: 'number' },
+          user: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              roles: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string' },
+                    permissions: {
+                      type: 'array',
+                      items: {
+                        type: 'string',
+                        enum: ['read', 'write', 'admin'],
+                      },
+                    },
+                  },
+                  required: ['name', 'permissions'],
+                },
+              },
+            },
+            required: ['name', 'roles'],
+          },
+        },
+        required: ['id', 'user'],
+      };
+
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const validData = {
+        id: 1,
+        user: {
+          name: 'John',
+          roles: [
+            {
+              name: 'moderator',
+              permissions: ['read', 'write'],
+            },
+          ],
+        },
+      };
+      if (zodSchema == null) {
+        throw new Error('Zod schema is null');
+      }
+
+      expect(zodSchema.parse(validData)).toEqual(validData);
+      expect(() =>
+        zodSchema.parse({
+          id: 1,
+          user: {
+            name: 'John',
+            roles: [
+              {
+                name: 'moderator',
+                permissions: ['invalid'],
+              },
+            ],
+          },
+        }),
+      ).toThrow();
+    });
+  });
+
+  // zod.spec.ts
+  describe('schema descriptions', () => {
+    it('should preserve top-level description', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        description: 'A test schema description',
+        properties: {
+          name: { type: 'string' },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+      expect(zodSchema?.description).toBe('A test schema description');
+    });
+
+    it('should preserve field descriptions', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+            description: 'The user\'s name',
+          },
+          age: {
+            type: 'number',
+            description: 'The user\'s age',
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const shape = (zodSchema as z.ZodObject<any>).shape;
+      expect(shape.name.description).toBe('The user\'s name');
+      expect(shape.age.description).toBe('The user\'s age');
+    });
+
+    it('should preserve descriptions in nested objects', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        description: 'User record',
+        properties: {
+          user: {
+            type: 'object',
+            description: 'User details',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'The user\'s name',
+              },
+              settings: {
+                type: 'object',
+                description: 'User preferences',
+                properties: {
+                  theme: {
+                    type: 'string',
+                    description: 'UI theme preference',
+                    enum: ['light', 'dark'],
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Type assertions for better type safety
+      const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+      expect(zodSchema?.description).toBe('User record');
+
+      if ('user' in shape) {
+        expect(shape.user.description).toBe('User details');
+
+        const userShape = shape.user instanceof z.ZodObject ? shape.user.shape : {};
+        if ('name' in userShape && 'settings' in userShape) {
+          expect(userShape.name.description).toBe('The user\'s name');
+          expect(userShape.settings.description).toBe('User preferences');
+
+          const settingsShape =
+            userShape.settings instanceof z.ZodObject ? userShape.settings.shape : {};
+          if ('theme' in settingsShape) {
+            expect(settingsShape.theme.description).toBe('UI theme preference');
+          }
+        }
+      }
+    });
+
+    it('should preserve descriptions in arrays', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            description: 'User tags',
+            items: {
+              type: 'string',
+              description: 'Individual tag',
+            },
+          },
+          scores: {
+            type: 'array',
+            description: 'Test scores',
+            items: {
+              type: 'number',
+              description: 'Individual score',
+            },
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const shape = (zodSchema as z.ZodObject<any>).shape;
+      expect(shape.tags.description).toBe('User tags');
+      expect(shape.scores.description).toBe('Test scores');
+    });
+
+    it('should preserve descriptions in enums', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          role: {
+            type: 'string',
+            description: 'User role in the system',
+            enum: ['admin', 'user', 'guest'],
+          },
+          status: {
+            type: 'string',
+            description: 'Account status',
+            enum: ['active', 'suspended', 'deleted'],
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const shape = (zodSchema as z.ZodObject<any>).shape;
+      expect(shape.role.description).toBe('User role in the system');
+      expect(shape.status.description).toBe('Account status');
+    });
+
+    it('should preserve descriptions in a complex schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        description: 'User profile configuration',
+        properties: {
+          basicInfo: {
+            type: 'object',
+            description: 'Basic user information',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Full name of the user',
+              },
+              age: {
+                type: 'number',
+                description: 'User age in years',
+              },
+            },
+            required: ['name'],
+          },
+          preferences: {
+            type: 'object',
+            description: 'User preferences',
+            properties: {
+              notifications: {
+                type: 'array',
+                description: 'Notification settings',
+                items: {
+                  type: 'object',
+                  description: 'Individual notification preference',
+                  properties: {
+                    type: {
+                      type: 'string',
+                      description: 'Type of notification',
+                      enum: ['email', 'sms', 'push'],
+                    },
+                    enabled: {
+                      type: 'boolean',
+                      description: 'Whether this notification is enabled',
+                    },
+                  },
+                },
+              },
+              theme: {
+                type: 'string',
+                description: 'UI theme preference',
+                enum: ['light', 'dark', 'system'],
+              },
+            },
+          },
+        },
+      };
+
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Test top-level description
+      expect(zodSchema?.description).toBe('User profile configuration');
+
+      const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+
+      // Test basic info descriptions
+      if ('basicInfo' in shape) {
+        expect(shape.basicInfo.description).toBe('Basic user information');
+        const basicInfoShape = shape.basicInfo instanceof z.ZodObject ? shape.basicInfo.shape : {};
+
+        if ('name' in basicInfoShape && 'age' in basicInfoShape) {
+          expect(basicInfoShape.name.description).toBe('Full name of the user');
+          expect(basicInfoShape.age.description).toBe('User age in years');
+        }
+      }
+
+      // Test preferences descriptions
+      if ('preferences' in shape) {
+        expect(shape.preferences.description).toBe('User preferences');
+        const preferencesShape =
+          shape.preferences instanceof z.ZodObject ? shape.preferences.shape : {};
+
+        if ('notifications' in preferencesShape && 'theme' in preferencesShape) {
+          expect(preferencesShape.notifications.description).toBe('Notification settings');
+          expect(preferencesShape.theme.description).toBe('UI theme preference');
+        }
+      }
+    });
+  });
+
+  describe('empty object handling', () => {
+    it('should return undefined for empty object schemas when allowEmptyObject is false', () => {
+      const emptyObjectSchemas = [
+        { type: 'object' as const },
+        { type: 'object' as const, properties: {} },
+      ];
+
+      emptyObjectSchemas.forEach((schema) => {
+        expect(convertJsonSchemaToZod(schema, { allowEmptyObject: false })).toBeUndefined();
+      });
+    });
+
+    it('should return zod schema for empty object schemas when allowEmptyObject is true', () => {
+      const emptyObjectSchemas = [
+        { type: 'object' as const },
+        { type: 'object' as const, properties: {} },
+      ];
+
+      emptyObjectSchemas.forEach((schema) => {
+        const result = convertJsonSchemaToZod(schema, { allowEmptyObject: true });
+        expect(result).toBeDefined();
+        expect(result instanceof z.ZodObject).toBeTruthy();
+      });
+    });
+
+    it('should return zod schema for empty object schemas by default', () => {
+      const emptyObjectSchemas = [
+        { type: 'object' as const },
+        { type: 'object' as const, properties: {} },
+      ];
+
+      emptyObjectSchemas.forEach((schema) => {
+        const result = convertJsonSchemaToZod(schema);
+        expect(result).toBeDefined();
+        expect(result instanceof z.ZodObject).toBeTruthy();
+      });
+    });
+
+    it('should still convert non-empty object schemas regardless of allowEmptyObject setting', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+        },
+      };
+
+      const resultWithFlag = convertJsonSchemaToZod(schema, { allowEmptyObject: false });
+      const resultWithoutFlag = convertJsonSchemaToZod(schema);
+
+      expect(resultWithFlag).toBeDefined();
+      expect(resultWithoutFlag).toBeDefined();
+      expect(resultWithFlag instanceof z.ZodObject).toBeTruthy();
+      expect(resultWithoutFlag instanceof z.ZodObject).toBeTruthy();
+    });
+  });
+});

package/src/zod.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+
+export type JsonSchemaType = {
+  type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+  enum?: string[];
+  items?: JsonSchemaType;
+  properties?: Record<string, JsonSchemaType>;
+  required?: string[];
+  description?: string;
+};
+
+function isEmptyObjectSchema(jsonSchema?: JsonSchemaType): boolean {
+  return (
+    jsonSchema != null &&
+    typeof jsonSchema === 'object' &&
+    jsonSchema.type === 'object' &&
+    (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0)
+  );
+}
+
+export function convertJsonSchemaToZod(
+  schema: JsonSchemaType,
+  options: { allowEmptyObject?: boolean } = {},
+): z.ZodType | undefined {
+  const { allowEmptyObject = true } = options;
+  if (!allowEmptyObject && isEmptyObjectSchema(schema)) {
+    return undefined;
+  }
+
+  let zodSchema: z.ZodType;
+
+  // Handle primitive types
+  if (schema.type === 'string') {
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+      const [first, ...rest] = schema.enum;
+      zodSchema = z.enum([first, ...rest] as [string, ...string[]]);
+    } else {
+      zodSchema = z.string();
+    }
+  } else if (schema.type === 'number') {
+    zodSchema = z.number();
+  } else if (schema.type === 'boolean') {
+    zodSchema = z.boolean();
+  } else if (schema.type === 'array' && schema.items !== undefined) {
+    const itemSchema = convertJsonSchemaToZod(schema.items);
+    zodSchema = z.array(itemSchema as z.ZodType);
+  } else if (schema.type === 'object') {
+    const shape: Record<string, z.ZodType> = {};
+    const properties = schema.properties ?? {};
+
+    for (const [key, value] of Object.entries(properties)) {
+      let fieldSchema = convertJsonSchemaToZod(value);
+      if (!fieldSchema) {
+        continue;
+      }
+      if (value.description != null && value.description !== '') {
+        fieldSchema = fieldSchema.describe(value.description);
+      }
+      shape[key] = fieldSchema;
+    }
+
+    let objectSchema = z.object(shape);
+
+    if (Array.isArray(schema.required) && schema.required.length > 0) {
+      const partial = Object.fromEntries(
+        Object.entries(shape).map(([key, value]) => [
+          key,
+          schema.required?.includes(key) === true ? value : value.optional(),
+        ]),
+      );
+      objectSchema = z.object(partial);
+    } else {
+      objectSchema = objectSchema.partial();
+    }
+    zodSchema = objectSchema;
+  } else {
+    zodSchema = z.unknown();
+  }
+
+  // Add description if present
+  if (schema.description != null && schema.description !== '') {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+
+  return zodSchema;
+}

package/tsconfig.json

@@ -18,9 +18,8 @@
     "isolatedModules": true,
     "noEmit": true,
     "sourceMap": true,
-    "baseUrl": ".", // This should be the root of your package
+    "baseUrl": ".",
     "paths": {
-      // Add path mappings
       "librechat-data-provider/react-query": ["./src/react-query/index.ts"]
     }
   },