@vitnode/core 1.2.0-canary.47 → 1.2.0-canary.49

package/dist/src/lib/helpers/auto-form.test.js

@@ -1,175 +1,336 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
-import { getBaseSchema, getBaseType, getDefaultValueInZodStack, getDefaultValues, getObjectFormSchema, getShapeFromSchema } from "./auto-form.js";
+import { getDefaults, getNestedParam, getZodInputParams } from "./auto-form.js";
 describe('auto-form helpers', ()=>{
-    describe('getShapeFromSchema', ()=>{
-        it('should get shape from ZodObject', ()=>{
-            const schema = z.object({
-                name: z.string(),
-                age: z.number()
-            });
-            const shape = getShapeFromSchema(schema, 'name');
-            expect(shape?._def.typeName).toBe('ZodString');
+    describe('getDefaults', ()=>{
+        it('should return empty object when no schema provided', ()=>{
+            expect(getDefaults()).toEqual({});
         });
-        it('should get shape from ZodEffects', ()=>{
-            const schema = z.object({
-                name: z.string(),
-                age: z.number()
-            }).refine(()=>true);
-            const shape = getShapeFromSchema(schema, 'name');
-            expect(shape?._def.typeName).toBe('ZodString');
+        it('should return empty object when schema has no properties', ()=>{
+            const schema = {};
+            expect(getDefaults(schema)).toEqual({});
         });
-    });
-    describe('getObjectFormSchema', ()=>{
-        it('should return the same schema if already ZodObject', ()=>{
-            const schema = z.object({
-                name: z.string()
+        it('should extract default values from simple Zod schema', ()=>{
+            const zodSchema = z.object({
+                name: z.string().default('John Doe'),
+                age: z.number().default(25),
+                active: z.boolean().default(true)
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getDefaults(jsonSchema);
+            expect(result).toEqual({
+                name: 'John Doe',
+                age: 25,
+                active: true
             });
-            const result = getObjectFormSchema(schema);
-            expect(result).toBe(schema);
         });
-        it('should unwrap ZodEffects to get ZodObject', ()=>{
-            const innerSchema = z.object({
-                name: z.string()
+        it('should handle nested Zod objects with defaults', ()=>{
+            const zodSchema = z.object({
+                user: z.object({
+                    name: z.string().default('Jane'),
+                    settings: z.object({
+                        theme: z.string().default('dark'),
+                        notifications: z.boolean().default(false)
+                    })
+                }),
+                title: z.string().default('Hello')
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getDefaults(jsonSchema);
+            expect(result).toEqual({
+                user: {
+                    name: 'Jane',
+                    settings: {
+                        theme: 'dark',
+                        notifications: false
+                    }
+                },
+                title: 'Hello'
             });
-            const schema = innerSchema.refine(()=>true);
-            const result = getObjectFormSchema(schema);
-            expect(result).toBe(innerSchema);
         });
-    });
-    describe('getBaseSchema', ()=>{
-        it('should get base schema from simple schema', ()=>{
-            const schema = z.string();
-            const result = getBaseSchema(schema);
-            expect(result).toBe(schema);
-        });
-        it('should unwrap optional schema', ()=>{
-            const schema = z.string().optional();
-            const result = getBaseSchema(schema);
-            expect(result?._def.typeName).toBe('ZodString');
-        });
-        it('should handle array type when isArray is true', ()=>{
-            const schema = z.array(z.string());
-            const result = getBaseSchema(schema, true);
-            expect(result?._def.typeName).toBe('ZodString');
+        it('should skip nested objects with no default values', ()=>{
+            const zodSchema = z.object({
+                user: z.object({
+                    name: z.string(),
+                    email: z.string()
+                }),
+                title: z.string().default('Hello')
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getDefaults(jsonSchema);
+            expect(result).toEqual({
+                title: 'Hello'
+            });
+        });
+        it('should handle mixed properties with and without defaults', ()=>{
+            const zodSchema = z.object({
+                name: z.string().default('Test'),
+                email: z.string(),
+                age: z.number().default(30),
+                bio: z.string()
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getDefaults(jsonSchema);
+            expect(result).toEqual({
+                name: 'Test',
+                age: 30
+            });
         });
     });
-    describe('getBaseType', ()=>{
-        it('should return type name of simple schema', ()=>{
-            const schema = z.string();
-            expect(getBaseType(schema)).toBe('ZodString');
+    describe('getZodInputParams', ()=>{
+        it('should return empty object when no schema provided', ()=>{
+            expect(getZodInputParams()).toEqual({});
         });
-        it('should return type name from optional schema', ()=>{
-            const schema = z.string().optional();
-            expect(getBaseType(schema)).toBe('ZodString');
+        it('should return empty object when schema has no properties', ()=>{
+            const schema = {};
+            expect(getZodInputParams(schema)).toEqual({});
         });
-        it('should return type name from refined schema', ()=>{
-            const schema = z.string().refine(()=>true);
-            expect(getBaseType(schema)).toBe('ZodString');
+        it('should extract basic string field parameters from Zod schema', ()=>{
+            const zodSchema = z.object({
+                name: z.string().min(2).max(50).regex(/^[a-zA-Z]+$/).describe('User name')
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema, [
+                'name'
+            ]);
+            expect(result).toEqual({
+                name: {
+                    type: 'text',
+                    minLength: 2,
+                    maxLength: 50,
+                    pattern: '^[a-zA-Z]+$',
+                    description: 'User name',
+                    required: true
+                }
+            });
         });
-    });
-    describe('getDefaultValueInZodStack', ()=>{
-        it('should get default value from ZodDefault', ()=>{
-            const schema = z.string().default('test');
-            expect(getDefaultValueInZodStack(schema)).toBe('test');
+        it('should handle email format from Zod schema', ()=>{
+            const zodSchema = z.object({
+                email: z.email().describe('Email address')
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema, [
+                'email'
+            ]);
+            expect(result.email).toHaveProperty('type', 'email');
+            expect(result.email).toHaveProperty('description', 'Email address');
+            expect(result.email).toHaveProperty('required', true);
+            expect(result.email).toHaveProperty('pattern'); // Email pattern is generated
         });
-        it('should get default value from nested ZodDefault', ()=>{
-            const schema = z.string().default('test').optional();
-            expect(getDefaultValueInZodStack(schema)).toBe('test');
+        it('should infer password type from field name', ()=>{
+            const zodSchema = z.object({
+                password: z.string(),
+                confirmPassword: z.string(),
+                userPassword: z.string()
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema);
+            expect(result.password).toHaveProperty('type', 'password');
+            expect(result.password).toHaveProperty('required', true);
+            expect(result.confirmPassword).toHaveProperty('type', 'password');
+            expect(result.confirmPassword).toHaveProperty('required', true);
+            expect(result.userPassword).toHaveProperty('type', 'password');
+            expect(result.userPassword).toHaveProperty('required', true);
         });
-        it('should return undefined when no default value exists', ()=>{
-            const schema = z.string();
-            expect(getDefaultValueInZodStack(schema)).toBeUndefined();
+        it('should handle number and boolean types from Zod schema', ()=>{
+            const zodSchema = z.object({
+                age: z.number(),
+                count: z.number().int(),
+                active: z.boolean()
+            });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema);
+            expect(result.age).toHaveProperty('type', 'number');
+            expect(result.age).toHaveProperty('required', true);
+            expect(result.count).toHaveProperty('type', 'number');
+            expect(result.count).toHaveProperty('required', true);
+            expect(result.active).toHaveProperty('type', 'checkbox');
+            expect(result.active).toHaveProperty('required', true);
         });
-    });
-    describe('getDefaultValues', ()=>{
-        it('should get default values from flat object schema', ()=>{
-            const schema = z.object({
-                name: z.string().default('John'),
-                age: z.number().default(25)
+        it('should handle enum values from Zod schema', ()=>{
+            const zodSchema = z.object({
+                role: z.enum([
+                    'admin',
+                    'user',
+                    'guest'
+                ])
             });
-            const defaults = getDefaultValues(schema);
-            expect(defaults).toEqual({
-                name: 'John',
-                age: 25
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema);
+            expect(result.role).toHaveProperty('type', 'text');
+            expect(result.role).toHaveProperty('enum', [
+                'admin',
+                'user',
+                'guest'
+            ]);
+            expect(result.role).toHaveProperty('required', true);
+        });
+        it('should handle complex password validation', ()=>{
+            const zodSchema = z.object({
+                password: z.string().min(8).regex(/(?=.*[a-z])/, 'Must contain lowercase').regex(/(?=.*[A-Z])/, 'Must contain uppercase').regex(/(?=.*\d)/, 'Must contain number')
             });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema);
+            expect(result.password).toHaveProperty('type', 'password');
+            expect(result.password).toHaveProperty('minLength', 8);
         });
-        it('should get default values from nested object schema', ()=>{
-            const schema = z.object({
+        it('should handle nested objects from Zod schema', ()=>{
+            const zodSchema = z.object({
                 user: z.object({
-                    name: z.string().default('John'),
-                    age: z.number().default(25)
+                    name: z.string(),
+                    email: z.email()
+                }),
+                settings: z.object({
+                    theme: z.enum([
+                        'light',
+                        'dark'
+                    ]),
+                    notifications: z.boolean()
                 })
             });
-            const defaults = getDefaultValues(schema);
-            expect(defaults).toEqual({
-                user: {
-                    name: 'John',
-                    age: 25
-                }
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema, [
+                'user'
+            ]);
+            expect(result.user).toHaveProperty('name');
+            expect(result.user).toHaveProperty('email');
+            expect(result.settings).toHaveProperty('theme');
+            expect(result.settings).toHaveProperty('notifications');
+        });
+        it('should handle required fields from Zod schema', ()=>{
+            const zodSchema = z.object({
+                name: z.string(),
+                email: z.string(),
+                age: z.number().optional()
             });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema, [
+                'name',
+                'email'
+            ]);
+            expect(result.name).toHaveProperty('required', true);
+            expect(result.email).toHaveProperty('required', true);
+            expect(result.age).not.toHaveProperty('required');
         });
-        it('should handle schema with no defaults', ()=>{
-            const schema = z.object({
+        it('should handle optional fields from Zod schema', ()=>{
+            const zodSchema = z.object({
                 name: z.string(),
-                age: z.number()
+                email: z.string().optional(),
+                age: z.number().optional()
             });
-            const defaults = getDefaultValues(schema);
-            expect(defaults).toEqual({});
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema, [
+                'name'
+            ]);
+            expect(result.name).toHaveProperty('required', true);
+            expect(result.email).not.toHaveProperty('required');
+            expect(result.age).not.toHaveProperty('required');
         });
-        it('should handle complex default values with conditional logic', ()=>{
-            const data = {
-                category: {
-                    id: 123,
-                    title: 'Technology'
-                }
-            };
-            const schema = z.object({
-                title: z.string().default('Default Title'),
-                categoryId: z.object({
-                    value: z.string(),
-                    label: z.string()
-                }).default(data?.category ? {
-                    value: data.category.id.toString(),
-                    label: data.category.title
-                } : {
-                    value: '',
-                    label: ''
-                })
+        it('should handle union types from Zod schema', ()=>{
+            const zodSchema = z.object({
+                status: z.union([
+                    z.literal('active'),
+                    z.literal('inactive')
+                ]),
+                priority: z.number().or(z.string())
             });
-            const defaults = getDefaultValues(schema);
-            expect(defaults).toEqual({
-                title: 'Default Title',
-                categoryId: {
-                    value: '123',
-                    label: 'Technology'
-                }
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema);
+            expect(result).toHaveProperty('status');
+            expect(result).toHaveProperty('priority');
+        });
+        it('should handle array types from Zod schema', ()=>{
+            const zodSchema = z.object({
+                tags: z.array(z.string()),
+                numbers: z.array(z.number())
             });
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            const result = getZodInputParams(jsonSchema);
+            expect(result).toHaveProperty('tags');
+            expect(result).toHaveProperty('numbers');
         });
-        it('should handle complex default values with falsy data', ()=>{
-            // Test with a simpler approach - using a function that returns the default value
-            const getDefaultCategoryId = ()=>({
-                    value: '',
-                    label: ''
-                });
-            const schema = z.object({
-                categoryId: z.object({
-                    value: z.string(),
-                    label: z.string()
-                }).default(getDefaultCategoryId())
-            });
-            const defaults = getDefaultValues(schema);
-            expect(defaults).toEqual({
-                categoryId: {
-                    value: '',
-                    label: ''
+    });
+    describe('getNestedParam', ()=>{
+        const testObj = {
+            user: {
+                name: {
+                    type: 'text',
+                    required: true
+                },
+                email: {
+                    type: 'email'
+                },
+                settings: {
+                    theme: {
+                        type: 'text',
+                        enum: [
+                            'light',
+                            'dark'
+                        ]
+                    },
+                    notifications: {
+                        type: 'checkbox'
+                    }
                 }
+            },
+            title: {
+                type: 'text',
+                default: 'Hello'
+            }
+        };
+        it('should get top-level properties', ()=>{
+            const result = getNestedParam(testObj, 'title');
+            expect(result).toEqual({
+                type: 'text',
+                default: 'Hello'
+            });
+        });
+        it('should get nested properties', ()=>{
+            const result = getNestedParam(testObj, 'user.name');
+            expect(result).toEqual({
+                type: 'text',
+                required: true
+            });
+        });
+        it('should get deeply nested properties', ()=>{
+            const result = getNestedParam(testObj, 'user.settings.theme');
+            expect(result).toEqual({
+                type: 'text',
+                enum: [
+                    'light',
+                    'dark'
+                ]
             });
         });
-        it('should return empty object for schema without shape', ()=>{
-            const schema = z.string();
-            const defaults = getDefaultValues(schema);
-            expect(defaults).toEqual({});
+        it('should return undefined for non-existent paths', ()=>{
+            expect(getNestedParam(testObj, 'nonexistent')).toBeUndefined();
+            expect(getNestedParam(testObj, 'user.nonexistent')).toBeUndefined();
+            expect(getNestedParam(testObj, 'user.settings.nonexistent')).toBeUndefined();
+        });
+        it('should return undefined for invalid paths', ()=>{
+            expect(getNestedParam(testObj, 'title.invalid')).toBeUndefined();
+            expect(getNestedParam(testObj, 'user.name.invalid')).toBeUndefined();
+        });
+        it('should handle empty path', ()=>{
+            const result = getNestedParam(testObj, '');
+            expect(result).toBeUndefined(); // Empty string path returns undefined
+        });
+        it('should handle paths with array values safely', ()=>{
+            const objWithArray = {
+                items: {
+                    enum: [
+                        'a',
+                        'b',
+                        'c'
+                    ]
+                }
+            };
+            const result = getNestedParam(objWithArray, 'items.enum');
+            expect(result).toEqual([
+                'a',
+                'b',
+                'c'
+            ]); // Arrays are accessible as normal properties
         });
     });
 });

package/dist/src/lib/navigation.d.ts

@@ -4,7 +4,7 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     slot?: string | undefined | undefined;
     style?: import("react").CSSProperties | undefined;
     title?: string | undefined | undefined;
-    locale?: import("next-intl").Locale | undefined;
+    locale?: import("use-intl").Locale | undefined;
     onError?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     children?: import("react").ReactNode;
     ref?: import("react").Ref<HTMLAnchorElement> | undefined;
@@ -306,19 +306,19 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
         pathname: string;
         query?: QueryParams;
     }, options?: (Partial<import("next/dist/shared/lib/app-router-context.shared-runtime").NavigateOptions> & {
-        locale?: import("next-intl").Locale;
+        locale?: import("use-intl").Locale;
     }) | undefined) => void;
     replace: (href: string | {
         pathname: string;
         query?: QueryParams;
     }, options?: (Partial<import("next/dist/shared/lib/app-router-context.shared-runtime").NavigateOptions> & {
-        locale?: import("next-intl").Locale;
+        locale?: import("use-intl").Locale;
     }) | undefined) => void;
     prefetch: (href: string | {
         pathname: string;
         query?: QueryParams;
     }, options?: (Partial<import("next/dist/shared/lib/app-router-context.shared-runtime").PrefetchOptions> & {
-        locale?: import("next-intl").Locale;
+        locale?: import("use-intl").Locale;
     }) | undefined) => void;
     back(): void;
     forward(): void;
@@ -328,7 +328,7 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
         pathname: string;
         query?: QueryParams;
     };
-    locale: import("next-intl").Locale;
+    locale: import("use-intl").Locale;
     forcePrefix?: boolean;
 }) => string;
 declare const redirect: (href: string | {

package/dist/src/views/admin/views/core/debug/system-logs/actions/more/more.d.ts

@@ -1,20 +1,20 @@
 import React from 'react';
 declare const ContentMoreActionSystemLogs: React.ComponentType<{
-    method: string;
+    id: number;
+    pluginId: string;
+    type: "warn" | "error" | "debug";
+    content: string;
+    createdAt: Date;
     ipAddress: string;
+    method: string;
+    path: string;
+    userAgent: string | null;
+    statusCode: number;
     user: {
         id: number;
         name: string;
         nameCode: string;
     } | null;
-    id: number;
-    content: string;
-    type: "warn" | "error" | "debug";
-    createdAt: Date;
-    userAgent: string | null;
-    path: string;
-    pluginId: string;
-    statusCode: number;
 }>;
 export declare const MoreActionSystemLogs: (props: React.ComponentProps<typeof ContentMoreActionSystemLogs>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/views/admin/views/core/debug/system-logs/system-logs-view.d.ts

@@ -1,24 +1,24 @@
 export declare const getSystemLogsData: (query: Record<string, string | string[] | undefined>) => Promise<{
     edges: {
-        method: string;
+        id: number;
+        pluginId: string;
+        type: "warn" | "error" | "debug";
+        content: string;
+        createdAt: Date;
         ipAddress: string;
+        method: string;
+        path: string;
+        userAgent: string | null;
+        statusCode: number;
         user: {
             id: number;
             name: string;
             nameCode: string;
         } | null;
-        id: number;
-        content: string;
-        type: "warn" | "error" | "debug";
-        createdAt: Date;
-        userAgent: string | null;
-        path: string;
-        pluginId: string;
-        statusCode: number;
     }[];
     pageInfo: {
-        count: number;
         totalCount: number;
+        count: number;
         hasNextPage: boolean;
         hasPreviousPage: boolean;
         startCursor: number | null;

package/dist/src/views/admin/views/core/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../../../../src/views/admin/views/core/test.tsx"],"names":[],"mappings":"AAcA,eAAO,MAAM,QAAQ,+CA6IpB,CAAC"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../../../../src/views/admin/views/core/test.tsx"],"names":[],"mappings":"AAcA,eAAO,MAAM,QAAQ,+CA0JpB,CAAC"}

package/dist/src/views/admin/views/core/test.js

@@ -14,13 +14,13 @@ export const TestView = ()=>{
     const formSchema = z.object({
         provider: z.string().min(1, {
             message: 'Provider is required'
-        }),
+        }).describe('This is the provider for your application. It should be a valid provider name.'),
         client_secret: z.string().min(1, {
             message: 'Client Secret is required'
-        }),
+        }).describe('This is the client secret for your application. It should be kept secret and not shared with anyone.'),
         terms: z.boolean().refine((val)=>val, {
             message: 'You must accept the terms and conditions'
-        }),
+        }).describe('By checking this box, you agree to the terms and conditions.'),
         options: z.enum([
             'option1',
             'option2',
@@ -31,7 +31,7 @@ export const TestView = ()=>{
             'option2',
             'option3'
         ]).default('option2'),
-        switch: z.boolean().default(false),
+        switch: z.boolean().default(false).describe('elo'),
         type: z.enum([
             'option-one',
             'option-two'
@@ -115,9 +115,9 @@ export const TestView = ()=>{
                     {
                         id: 'switch',
                         component: (props)=>/*#__PURE__*/ _jsx(AutoFormSwitch, {
+                                ...props,
                                 description: "By checking this box, you agree to the terms and conditions.",
-                                label: "I agree to the terms and conditions",
-                                ...props
+                                label: "I agree to the terms and conditions"
                             })
                     },
                     {

package/dist/src/views/auth/components/password-input.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { ItemAutoFormComponentProps } from '../../../components/form/auto-form';
 import { Input } from '../../../components/ui/input';
-export declare const PasswordInput: ({ value: valueFromProps, ...props }: Omit<React.ComponentProps<typeof Input>, "type">) => import("react/jsx-runtime").JSX.Element;
+export declare const PasswordInput: ({ label, description: _, field, otherProps: { maxLength, minLength, pattern }, ...props }: ItemAutoFormComponentProps & Omit<React.ComponentProps<typeof Input>, "type">) => import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=password-input.d.ts.map

package/dist/src/views/auth/components/password-input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"password-input.d.ts","sourceRoot":"","sources":["../../../../../src/views/auth/components/password-input.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAQ9C,eAAO,MAAM,aAAa,GAAI,qCAG3B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,KAAK,CAAC,EAAE,MAAM,CAAC,4CAyElD,CAAC"}
+{"version":3,"file":"password-input.d.ts","sourceRoot":"","sources":["../../../../../src/views/auth/components/password-input.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAI9E,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAQ9C,eAAO,MAAM,aAAa,GAAI,2FAO3B,0BAA0B,GAC3B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,KAAK,CAAC,EAAE,MAAM,CAAC,4CA+EjD,CAAC"}