From c404e613f5e98deedaae2c04a6dfdf21adeee107 Mon Sep 17 00:00:00 2001 From: babayaga Date: Thu, 20 Feb 2025 18:14:32 +0100 Subject: [PATCH] zod --- packages/commons/dist/schemas/index.d.ts | 23 ++ packages/commons/dist/schemas/index.js | 204 +++++++++++++++++ packages/commons/dist/schemas/openapi.d.ts | 1 + packages/commons/dist/schemas/openapi.js | 22 ++ packages/commons/dist/schemas/path.d.ts | 30 +++ packages/commons/dist/schemas/path.js | 237 +++++++++++++++++++ packages/commons/dist/schemas/types.d.ts | 194 ++++++++++++++++ packages/commons/dist/schemas/types.js | 140 ++++++++++++ packages/commons/dist/schemas/vfs.d.ts | 1 + packages/commons/dist/schemas/vfs.js | 3 + packages/commons/dist/schemas/zod_map.d.ts | 46 ++++ packages/commons/dist/schemas/zod_map.js | 99 ++++++++ packages/commons/src/schemas/index.ts | 211 +++++++++++++++++ packages/commons/src/schemas/openapi.ts | 20 ++ packages/commons/src/schemas/path.ts | 253 +++++++++++++++++++++ packages/commons/src/schemas/types.ts | 187 +++++++++++++++ packages/commons/src/schemas/vfs.ts | 1 + packages/commons/src/schemas/zod_map.ts | 109 +++++++++ 18 files changed, 1781 insertions(+) create mode 100644 packages/commons/dist/schemas/index.d.ts create mode 100644 packages/commons/dist/schemas/index.js create mode 100644 packages/commons/dist/schemas/openapi.d.ts create mode 100644 packages/commons/dist/schemas/openapi.js create mode 100644 packages/commons/dist/schemas/path.d.ts create mode 100644 packages/commons/dist/schemas/path.js create mode 100644 packages/commons/dist/schemas/types.d.ts create mode 100644 packages/commons/dist/schemas/types.js create mode 100644 packages/commons/dist/schemas/vfs.d.ts create mode 100644 packages/commons/dist/schemas/vfs.js create mode 100644 packages/commons/dist/schemas/zod_map.d.ts create mode 100644 packages/commons/dist/schemas/zod_map.js create mode 100644 packages/commons/src/schemas/index.ts create mode 100644 packages/commons/src/schemas/openapi.ts create mode 100644 packages/commons/src/schemas/path.ts create mode 100644 packages/commons/src/schemas/types.ts create mode 100644 packages/commons/src/schemas/vfs.ts create mode 100644 packages/commons/src/schemas/zod_map.ts diff --git a/packages/commons/dist/schemas/index.d.ts b/packages/commons/dist/schemas/index.d.ts new file mode 100644 index 00000000..6775674b --- /dev/null +++ b/packages/commons/dist/schemas/index.d.ts @@ -0,0 +1,23 @@ +import * as CLI from 'yargs'; +import { z, ZodTypeAny, ZodObject } from 'zod'; +export * from './path.js'; +export * from './zod_map.js'; +export declare const generate_interfaces: (schemas: ZodObject[], dst: string) => void; +export declare const enumerateHelpStrings: (schema: ZodTypeAny, path: string[], logger: any) => void; +export declare const yargsDefaults: (yargs: CLI.Argv) => any; +export declare const getInnerSchema: (schema: ZodTypeAny) => ZodTypeAny; +export declare const getInnerType: (type: ZodTypeAny) => any; +export declare const getDefaultValue: (schema: ZodTypeAny) => any; +export declare const getFieldDefaultValue: (schema: ZodTypeAny) => any | undefined; +export declare const getDescription: (schema: ZodTypeAny) => string | undefined; +export declare const toYargs: (yargs: CLI.Argv, zodSchema: ZodObject, options?: { + onKey?: (yargs: CLI.Argv, key: string, options: any) => any; +}) => CLI.Argv; +export declare const WRITERS: { + '.json': (data: any, file: string, name: string, options: {}) => void; +}; +export declare const writer: (file: string) => any; +export declare const write: (schemas: ZodObject[], file: string, name: string, options: {}) => void; +export declare const combineValidatorsOr: (validators: z.ZodTypeAny[]) => z.ZodEffects; +export declare const combineValidatorsOrUsingZod: (validators: z.ZodTypeAny[]) => z.ZodTypeAny; +export declare const combineValidatorsOrUsingZod2: (validators: z.ZodTypeAny[]) => z.ZodTypeAny; diff --git a/packages/commons/dist/schemas/index.js b/packages/commons/dist/schemas/index.js new file mode 100644 index 00000000..c59d02a4 --- /dev/null +++ b/packages/commons/dist/schemas/index.js @@ -0,0 +1,204 @@ +import * as path from 'path'; +import { z, ZodObject, ZodEffects, ZodOptional, ZodDefault } from 'zod'; +import { sync as writeFS } from '@polymech/fs/write'; +import { zodToTs, printNode } from 'zod-to-ts'; +import { zodToJsonSchema } from "zod-to-json-schema"; +import { logger } from '@/logger.js'; +export * from './path.js'; +export * from './zod_map.js'; +export const generate_interfaces = (schemas, dst) => { + const types = schemas.map(schema => `export interface ${schema.description || 'IOptions'} ${printNode(zodToTs(schema).node)}`); + writeFS(dst, types.join('\n')); +}; +export const enumerateHelpStrings = (schema, path = [], logger) => { + if (schema instanceof ZodObject) { + for (const key in schema.shape) { + const nestedSchema = schema.shape[key]; + enumerateHelpStrings(nestedSchema, [...path, key], logger); + } + } + else { + const description = schema._def.description; + if (description) { + logger.debug(`\t ${path.join('.')}: ${description}`); + } + } +}; +export const yargsDefaults = (yargs) => yargs.parserConfiguration({ "camel-case-expansion": false }); +export const getInnerSchema = (schema) => { + while (schema instanceof ZodEffects) { + schema = schema._def.schema; + } + return schema; +}; +export const getInnerType = (type) => { + while (type instanceof ZodOptional) { + type = type._def.innerType; + } + while (type._def.typeName === 'ZodDefault' || type._def.typeName === 'ZodOptional') { + type = type._def.innerType; + } + return type._def.typeName; +}; +export const getDefaultValue = (schema) => { + if (schema instanceof ZodDefault) { + return schema._def.defaultValue(); + } + return undefined; +}; +export const getFieldDefaultValue = (schema) => { + if (!schema) { + return undefined; + } + if (schema._def.typeName === 'ZodDefault') { + return schema._def.defaultValue(); + } + if (schema instanceof ZodOptional) { + return getFieldDefaultValue(schema.unwrap()); + } + if (schema instanceof ZodEffects) { + return getFieldDefaultValue(schema._def.schema); + } + if (typeof schema._def) { + return getFieldDefaultValue(schema._def.schema); + } + return undefined; +}; +export const getDescription = (schema) => { + if (!schema) { + return undefined; + } + if (schema._def.description) { + return schema._def.description; + } + if (schema instanceof ZodOptional) { + return getDescription(schema.unwrap()); + } + if (schema instanceof ZodEffects) { + return getDescription(schema._def.schema); + } + if (typeof schema._def) { + return getDescription(schema._def.schema); + } + return undefined; +}; +export const toYargs = (yargs, zodSchema, options) => { + yargsDefaults(yargs); + try { + const shape = zodSchema.shape; + for (const key in shape) { + const zodField = shape[key]; + const innerDef = getInnerSchema(zodField); + if (!innerDef) { + continue; + } + let type; + const inner_type = getInnerType(innerDef); + let descriptionExtra = ''; + switch (inner_type) { + case 'ZodString': + type = 'string'; + break; + case 'ZodBoolean': + type = 'boolean'; + break; + case 'ZodNumber': + type = 'number'; + break; + case 'ZodOptional': + case 'ZodEnum': + type = getInnerType(innerDef); + if (innerDef._def.typeName === 'ZodEnum') { + descriptionExtra = `\n\t ${innerDef._def.values.join(' \n\t ')}`; + } + break; + } + const defaultValue = getFieldDefaultValue(zodField); + let handled = false; + const args = { + type, + default: defaultValue, + describe: `${zodField._def.description || ''} ${descriptionExtra}`.trim() + }; + if (options?.onKey) { + handled = options.onKey(yargs, key, args); + } + if (!handled) { + yargs.option(key, args); + } + } + return yargs; + } + catch (error) { + logger.error('Error processing schema:', error); + return yargs; + } +}; +///////////////////////////////////////////////////////// +// +// Schema Writers +// +const extension = (file) => path.parse(file).ext; +const json = (data, file, name, options) => writeFS(file, data.map((s) => zodToJsonSchema(s, name))); +export const WRITERS = { + '.json': json +}; +export const writer = (file) => WRITERS[extension(file)]; +export const write = (schemas, file, name, options) => { + if (!WRITERS[extension(file)]) { + logger.error(`No writer found for file extension: ${extension(file)} : file: ${file}`); + return; + } + logger.debug(`Writing schema to ${file} : ${name}`); + try { + writer(file)(schemas, file, name, options); + } + catch (e) { + logger.trace(`Error writing schema to ${file} : ${name}`, e, e.stack, e.message); + } +}; +//////////////////////////////////////////////////////////////////// +// +// Schema Combinators +export const combineValidatorsOr = (validators) => { + return z.string().refine((value) => { + const errors = []; + const isValid = validators.some((validator) => { + try { + validator.parse(value); + return true; + } + catch (err) { + errors.push(err.errors); + return false; + } + }); + if (!isValid) { + throw new z.ZodError(errors.flat()); + } + return true; + }, 'Invalid value for all provided validators'); +}; +export const combineValidatorsOrUsingZod = (validators) => { + return validators.reduce((acc, validator) => acc.or(validator)); +}; +export const combineValidatorsOrUsingZod2 = (validators) => { + return validators.reduce((acc, validator) => { + return acc.or(validator).refine((value) => { + try { + acc.parse(value); + return true; + } + catch (errAcc) { + try { + validator.parse(value); + return true; + } + catch (errValidator) { + throw new z.ZodError([...errAcc.errors, ...errValidator.errors]); + } + } + }); + }); +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/commons/dist/schemas/openapi.d.ts b/packages/commons/dist/schemas/openapi.d.ts new file mode 100644 index 00000000..cb0ff5c3 --- /dev/null +++ b/packages/commons/dist/schemas/openapi.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/packages/commons/dist/schemas/openapi.js b/packages/commons/dist/schemas/openapi.js new file mode 100644 index 00000000..b2b9dc1d --- /dev/null +++ b/packages/commons/dist/schemas/openapi.js @@ -0,0 +1,22 @@ +export {}; +/* +export const openapi = (data: ZodObject[], file: string, name: string, options: {}) => { + const registry = new OpenAPIRegistry() + data.forEach((s) => registry.register(s.description, s)) + const generator = new OpenApiGeneratorV3(registry.definitions) + const component = generator.generateComponents() + // const content = stringifyYAML(component) + return component +} +*/ +/* +const yaml = (data: ZodObject[], file: string, name: string, options: {}) => { + const registry = new OpenAPIRegistry() + data.forEach((s) => registry.register(s.description, s)) + const generator = new OpenApiGeneratorV3(registry.definitions) + const component = generator.generateComponents() + logger.debug(`Writing schema to ${file} : ${name}`,component) + writeFS(file,stringifyYAML(component)) +} +*/ +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zY2hlbWFzL29wZW5hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7RUFTRTtBQUNGOzs7Ozs7Ozs7RUFTRSJ9 \ No newline at end of file diff --git a/packages/commons/dist/schemas/path.d.ts b/packages/commons/dist/schemas/path.d.ts new file mode 100644 index 00000000..2092e35a --- /dev/null +++ b/packages/commons/dist/schemas/path.d.ts @@ -0,0 +1,30 @@ +import { z, ZodTypeAny } from 'zod'; +export declare enum E_PATH { + ENSURE_PATH_EXISTS = 1, + INVALID_INPUT = 2, + ENSURE_DIRECTORY_WRITABLE = 3, + ENSURE_FILE_IS_JSON = 4, + ENSURE_PATH_IS_ABSOLUTE = 5, + ENSURE_PATH_IS_RELATIVE = 6, + GET_PATH_INFO = 7 +} +export declare const Transformers: Record; +export declare const TransformersDescription: { + description: string; + fn: any; +}[]; +export declare const extendSchema: (baseSchema: z.ZodObject, extend: Record) => z.ZodObject, "strip", z.ZodTypeAny, { + [x: string]: any; +}, { + [x: string]: any; +}>; +export declare const ENSURE_DIRECTORY_WRITABLE: (inputPath: string, ctx: any, variables: Record) => string; +export declare const IS_VALID_STRING: (inputPath: string) => boolean; +export declare const ENSURE_PATH_EXISTS: (inputPath: string, ctx: any, variables: Record) => string; +export declare const test: () => z.ZodObject, "strip", z.ZodTypeAny, { + [x: string]: any; +}, { + [x: string]: any; +}>; +export declare const Templates: Record; +export declare const extend: (baseSchema: ZodTypeAny, template: any, variables?: Record) => z.ZodTypeAny; diff --git a/packages/commons/dist/schemas/path.js b/packages/commons/dist/schemas/path.js new file mode 100644 index 00000000..1d4e61de --- /dev/null +++ b/packages/commons/dist/schemas/path.js @@ -0,0 +1,237 @@ +import { z } from 'zod'; +import * as path from 'path'; +import { accessSync, constants, lstatSync, existsSync } from 'fs'; +import { isString } from '@polymech/core/primitives'; +import { sync as exists } from '@polymech/fs/exists'; +import { sync as read } from '@polymech/fs/read'; +import { logger } from '@/logger.js'; +import { DEFAULT_VARS, resolve, template } from '@/variables.js'; +import { getDescription } from '@/schemas/index.js'; +import { isFile } from '@/lib/fs.js'; +const DefaultPathSchemaBase = z.string().describe('Path to a file or directory'); +const PathErrorMessages = { + INVALID_INPUT: 'INVALID_INPUT: ${inputPath}', + PATH_DOES_NOT_EXIST: 'Path does not exist ${inputPath} = ${resolvedPath}', + DIRECTORY_NOT_WRITABLE: 'Directory is not writable ${inputPath} = ${resolvedPath}', + NOT_A_DIRECTORY: 'Path is not a directory or does not exist ${inputPath} = ${resolvedPath}', + NOT_A_JSON_FILE: 'File is not a JSON file or does not exist ${inputPath} = ${resolvedPath}', + PATH_NOT_ABSOLUTE: 'Path is not absolute ${inputPath} = ${resolvedPath}', + PATH_NOT_RELATIVE: 'Path is not relative ${inputPath} = ${resolvedPath}', +}; +export var E_PATH; +(function (E_PATH) { + E_PATH[E_PATH["ENSURE_PATH_EXISTS"] = 1] = "ENSURE_PATH_EXISTS"; + E_PATH[E_PATH["INVALID_INPUT"] = 2] = "INVALID_INPUT"; + E_PATH[E_PATH["ENSURE_DIRECTORY_WRITABLE"] = 3] = "ENSURE_DIRECTORY_WRITABLE"; + E_PATH[E_PATH["ENSURE_FILE_IS_JSON"] = 4] = "ENSURE_FILE_IS_JSON"; + E_PATH[E_PATH["ENSURE_PATH_IS_ABSOLUTE"] = 5] = "ENSURE_PATH_IS_ABSOLUTE"; + E_PATH[E_PATH["ENSURE_PATH_IS_RELATIVE"] = 6] = "ENSURE_PATH_IS_RELATIVE"; + E_PATH[E_PATH["GET_PATH_INFO"] = 7] = "GET_PATH_INFO"; +})(E_PATH || (E_PATH = {})); +export const Transformers = { + resolve: (val, variables = {}) => { + if (!val) { + return null; + } + return { + resolved: path.resolve(resolve(val, false, variables)), + source: val + }; + }, + json: (val, variables = {}) => { + if (!val) { + return null; + } + const resolved = path.resolve(resolve(isString(val) ? val : val.source, false, variables)); + return { + resolved, + source: val, + value: read(resolved, 'json') + }; + }, + string: (val, variables = {}) => { + if (!val) { + return null; + } + let src = isString(val) ? val : val.source; + src = resolve(src, false, variables); + const resolved = path.resolve(src); + if (!exists(resolved) || !isFile(resolved)) { + return { + resolved, + source: val, + value: null + }; + } + else { + let value = null; + try { + value = read(resolved, 'string'); + } + catch (e) { + logger.error('Failed to read file', { resolved, source: val, error: e.message }); + } + return { + resolved, + source: val, + value + }; + } + } +}; +export const TransformersDescription = [ + { + description: 'RESOLVE_PATH', + fn: Transformers.resolve + }, + { + description: 'READ_JSON', + fn: Transformers.json + }, + { + description: 'READ_STRING', + fn: Transformers.string + } +]; +const extendType = (type, extend, variables = {}) => { + if (Array.isArray(extend.refine)) { + for (const refine of extend.refine) { + type = type.refine(refine); + } + } + else { + type = type.refine(extend.refine); + } + if (Array.isArray(extend.transform)) { + for (const transform of extend.transform) { + type = type.transform((val) => transform(val, variables)); + } + } + else { + type = type.transform(extend.transform); + } + return type; +}; +const extendTypeDescription = (type, extension, variables = {}) => { + const description = getDescription(type) || ''; + let transformerDescriptions = 'Transformers:\n'; + if (Array.isArray(extension.transform)) { + for (const transform of extension.transform) { + transformerDescriptions += transformerDescription(transform) + '\n'; + } + } + else { + transformerDescriptions += transformerDescription(extension.transform) + '\n'; + } + type = type.describe(description + '\n' + transformerDescriptions); + return type; +}; +const transformerDescription = (fn) => { + const description = TransformersDescription.find((t) => t.fn === fn); + return description ? description.description : 'Unknown'; +}; +export const extendSchema = (baseSchema, extend) => { + const baseShape = baseSchema.shape; + const extendedShape = { ...baseShape }; + for (const [key, refines] of Object.entries(extend)) { + if (!baseShape[key]) + continue; + let fieldSchema = baseShape[key]; + if (Array.isArray(refines.refine)) { + for (const refine of refines.refine) { + fieldSchema = fieldSchema.superRefine(refine); + } + } + else { + fieldSchema = fieldSchema.superRefine(refines); + } + if (Array.isArray(refines.transform)) { + for (const transform of refines.transform) { + fieldSchema = fieldSchema.transform((val) => transform(val)); + } + } + else { + fieldSchema = fieldSchema.transform(refines.transform); + } + extendedShape[key] = fieldSchema; + } + return z.object(extendedShape); +}; +export const ENSURE_DIRECTORY_WRITABLE = (inputPath, ctx, variables) => { + const resolvedPath = path.resolve(resolve(inputPath, false, variables)); + const parts = path.parse(resolvedPath); + if (resolvedPath && existsSync(parts.dir) && lstatSync(parts.dir).isDirectory()) { + try { + accessSync(resolvedPath, constants.W_OK); + return resolvedPath; + } + catch (e) { + ctx.addIssue({ + code: E_PATH.ENSURE_DIRECTORY_WRITABLE, + message: template(PathErrorMessages.DIRECTORY_NOT_WRITABLE, { inputPath, resolvedPath }) + }); + return z.NEVER; + } + } + else { + ctx.addIssue({ + code: E_PATH.ENSURE_DIRECTORY_WRITABLE, + message: template(PathErrorMessages.NOT_A_DIRECTORY, { inputPath, resolvedPath }) + }); + return z.NEVER; + } +}; +export const IS_VALID_STRING = (inputPath) => isString(inputPath); +export const ENSURE_PATH_EXISTS = (inputPath, ctx, variables) => { + if (!inputPath || !ctx) { + return z.NEVER; + } + if (!isString(inputPath)) { + ctx.addIssue({ + code: E_PATH.INVALID_INPUT, + message: template(PathErrorMessages.INVALID_INPUT, {}) + }); + return z.NEVER; + } + const resolvedPath = path.resolve(resolve(inputPath, false, variables)); + if (!exists(resolvedPath)) { + ctx.addIssue({ + code: E_PATH.ENSURE_PATH_EXISTS, + message: template(PathErrorMessages.PATH_DOES_NOT_EXIST, { inputPath, resolvedPath }) + }); + return z.NEVER; + } + return resolvedPath; +}; +export const test = () => { + const BaseCompilerOptions = () => z.object({ + root: DefaultPathSchemaBase.default(`${process.cwd()}`) + }); + const ret = extendSchema(BaseCompilerOptions(), { + root: { + refine: [ + (val, ctx) => ENSURE_DIRECTORY_WRITABLE(val, ctx, DEFAULT_VARS({ exampleVar: 'exampleValue' })), + (val, ctx) => ENSURE_PATH_EXISTS(val, ctx, DEFAULT_VARS({ exampleVar: 'exampleValue' })) + ], + transform: [ + (val) => path.resolve(resolve(val, false, DEFAULT_VARS({ exampleVar: 'exampleValue' }))) + ] + } + }); + return ret; +}; +export const Templates = { + json: { + refine: [IS_VALID_STRING, ENSURE_PATH_EXISTS], + transform: [Transformers.resolve, Transformers.json] + }, + string: { + refine: [ENSURE_PATH_EXISTS], + transform: [Transformers.resolve, Transformers.string] + } +}; +export const extend = (baseSchema, template, variables = {}) => { + const type = extendType(baseSchema, template, variables); + return extendTypeDescription(type, template, variables); +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"path.js","sourceRoot":"","sources":["../../src/schemas/path.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/commons/dist/schemas/types.d.ts b/packages/commons/dist/schemas/types.d.ts new file mode 100644 index 00000000..7126d7e8 --- /dev/null +++ b/packages/commons/dist/schemas/types.d.ts @@ -0,0 +1,194 @@ +export declare enum FLAG { + /** + * Instruct for no additional extra processing + * @constant + * @type int + */ + NONE = 0, + /** + * Will instruct the pre/post processor to base-64 decode or encode + * @constant + * @type int + */ + BASE_64 = 1, + /** + * Post/Pre process the value with a user function + * @constant + * @type int + */ + USE_FUNCTION = 2, + /** + * Replace variables with local scope's variables during the post/pre process + * @constant + * @type int + */ + REPLACE_VARIABLES = 4, + /** + * Replace variables with local scope's variables during the post/pre process but evaluate the whole string + * as Javascript + * @constant + * @type int + */ + REPLACE_VARIABLES_EVALUATED = 8, + /** + * Will instruct the pre/post processor to escpape evaluated or replaced variables or expressions + * @constant + * @type int + */ + ESCAPE = 16, + /** + * Will instruct the pre/post processor to replace block calls with oridinary vanilla script + * @constant + * @type int + */ + REPLACE_BLOCK_CALLS = 32, + /** + * Will instruct the pre/post processor to remove variable delimitters/placeholders from the final string + * @constant + * @type int + */ + REMOVE_DELIMTTERS = 64, + /** + * Will instruct the pre/post processor to remove "[" ,"]" , "(" , ")" , "{", "}" , "*" , "+" , "." + * @constant + * @type int + */ + ESCAPE_SPECIAL_CHARS = 128, + /** + * Will instruct the pre/post processor to use regular expressions over string substitution + * @constant + * @type int + */ + USE_REGEX = 256, + /** + * Will instruct the pre/post processor to use Filtrex (custom bison parser, needs xexpression) over string substitution + * @constant + * @type int + */ + USE_FILTREX = 512, + /** + * Cascade entry. There are cases where #USE_FUNCTION is not enough or we'd like to avoid further type checking. + * @constant + * @type int + */ + CASCADE = 1024, + /** + * Cascade entry. There are cases where #USE_FUNCTION is not enough or we'd like to avoid further type checking. + * @constant + * @type int + */ + EXPRESSION = 2048, + /** + * Dont parse anything + * @constant + * @type int + */ + DONT_PARSE = 4096, + /** + * Convert to hex + * @constant + * @type int + */ + TO_HEX = 8192, + /** + * Convert to hex + * @constant + * @type int + */ + REPLACE_HEX = 16384, + /** + * Wait for finish + * @constant + * @type int + */ + WAIT = 32768, + /** + * Wait for finish + * @constant + * @type int + */ + DONT_ESCAPE = 65536, + /** + * Flag to mark the maximum core bit mask, after here its user land + * @constant + * @type int + */ + END = 131072 +} +export declare enum EType { + Number = "Number", + String = "String", + Boolean = "Boolean", + Date = "Date", + TimeStamp = "TimeStamp", + Duration = "Duration", + Url = "Url", + UrlScheme = "Url-Scheme", + Asset = "Asset", + Symbol = "Symbol", + Value = "Value", + Values = "Values", + Attribute = "Attribute", + Parameter = "Parameter", + Operation = "Operation", + ParameterOperation = "ParameterOperation", + Template = "Template", + Arguments = "Arguments" +} +export type TVector2D = [number, number]; +export type TVector3D = [number, number, number]; +export type TBBox = [TVector3D, TVector3D]; +export type TQuaternion = [number, number, number, number]; +export type TFlags = Record; +export type TExpression = string | [string | RegExp, { + [key: string]: any; +}]; +export type TOptions = { + flags?: TFlags | { + [key: string]: any; + }; +}; +export interface IUrlScheme { + url: string; + options?: { + [key: string]: any; + }; +} +export interface IAsset { + urlScheme: IUrlScheme; + options?: { + [key: string]: any; + }; +} +export type TSelector = TExpression | [TExpression, { + [key: string]: any; +}]; +export interface ITypeInfo { + type: string; + symbol: bigint; +} +export interface IRef { + key: string | string; + struct: { + [key: string]: any; + }; +} +export interface IAttribute { + type: ITypeInfo; + value: bigint; +} +export interface IParameter { + type: ITypeInfo; + value: bigint; +} +export interface IParameterOperation { + param1: bigint; + param2: bigint; + operation: bigint; +} +export type TTemplate = string | [ITypeInfo | TSelector, { + [key: string]: any; +}]; +export type TArguments = { + [key: string]: any; +} | any[]; diff --git a/packages/commons/dist/schemas/types.js b/packages/commons/dist/schemas/types.js new file mode 100644 index 00000000..22bc28e5 --- /dev/null +++ b/packages/commons/dist/schemas/types.js @@ -0,0 +1,140 @@ +export var FLAG; +(function (FLAG) { + /** + * Instruct for no additional extra processing + * @constant + * @type int + */ + FLAG[FLAG["NONE"] = 0] = "NONE"; + /** + * Will instruct the pre/post processor to base-64 decode or encode + * @constant + * @type int + */ + FLAG[FLAG["BASE_64"] = 1] = "BASE_64"; + /** + * Post/Pre process the value with a user function + * @constant + * @type int + */ + FLAG[FLAG["USE_FUNCTION"] = 2] = "USE_FUNCTION"; + /** + * Replace variables with local scope's variables during the post/pre process + * @constant + * @type int + */ + FLAG[FLAG["REPLACE_VARIABLES"] = 4] = "REPLACE_VARIABLES"; + /** + * Replace variables with local scope's variables during the post/pre process but evaluate the whole string + * as Javascript + * @constant + * @type int + */ + FLAG[FLAG["REPLACE_VARIABLES_EVALUATED"] = 8] = "REPLACE_VARIABLES_EVALUATED"; + /** + * Will instruct the pre/post processor to escpape evaluated or replaced variables or expressions + * @constant + * @type int + */ + FLAG[FLAG["ESCAPE"] = 16] = "ESCAPE"; + /** + * Will instruct the pre/post processor to replace block calls with oridinary vanilla script + * @constant + * @type int + */ + FLAG[FLAG["REPLACE_BLOCK_CALLS"] = 32] = "REPLACE_BLOCK_CALLS"; + /** + * Will instruct the pre/post processor to remove variable delimitters/placeholders from the final string + * @constant + * @type int + */ + FLAG[FLAG["REMOVE_DELIMTTERS"] = 64] = "REMOVE_DELIMTTERS"; + /** + * Will instruct the pre/post processor to remove "[" ,"]" , "(" , ")" , "{", "}" , "*" , "+" , "." + * @constant + * @type int + */ + FLAG[FLAG["ESCAPE_SPECIAL_CHARS"] = 128] = "ESCAPE_SPECIAL_CHARS"; + /** + * Will instruct the pre/post processor to use regular expressions over string substitution + * @constant + * @type int + */ + FLAG[FLAG["USE_REGEX"] = 256] = "USE_REGEX"; + /** + * Will instruct the pre/post processor to use Filtrex (custom bison parser, needs xexpression) over string substitution + * @constant + * @type int + */ + FLAG[FLAG["USE_FILTREX"] = 512] = "USE_FILTREX"; + /** + * Cascade entry. There are cases where #USE_FUNCTION is not enough or we'd like to avoid further type checking. + * @constant + * @type int + */ + FLAG[FLAG["CASCADE"] = 1024] = "CASCADE"; + /** + * Cascade entry. There are cases where #USE_FUNCTION is not enough or we'd like to avoid further type checking. + * @constant + * @type int + */ + FLAG[FLAG["EXPRESSION"] = 2048] = "EXPRESSION"; + /** + * Dont parse anything + * @constant + * @type int + */ + FLAG[FLAG["DONT_PARSE"] = 4096] = "DONT_PARSE"; + /** + * Convert to hex + * @constant + * @type int + */ + FLAG[FLAG["TO_HEX"] = 8192] = "TO_HEX"; + /** + * Convert to hex + * @constant + * @type int + */ + FLAG[FLAG["REPLACE_HEX"] = 16384] = "REPLACE_HEX"; + /** + * Wait for finish + * @constant + * @type int + */ + FLAG[FLAG["WAIT"] = 32768] = "WAIT"; + /** + * Wait for finish + * @constant + * @type int + */ + FLAG[FLAG["DONT_ESCAPE"] = 65536] = "DONT_ESCAPE"; + /** + * Flag to mark the maximum core bit mask, after here its user land + * @constant + * @type int + */ + FLAG[FLAG["END"] = 131072] = "END"; +})(FLAG || (FLAG = {})); +export var EType; +(function (EType) { + EType["Number"] = "Number"; + EType["String"] = "String"; + EType["Boolean"] = "Boolean"; + EType["Date"] = "Date"; + EType["TimeStamp"] = "TimeStamp"; + EType["Duration"] = "Duration"; + EType["Url"] = "Url"; + EType["UrlScheme"] = "Url-Scheme"; + EType["Asset"] = "Asset"; + EType["Symbol"] = "Symbol"; + EType["Value"] = "Value"; + EType["Values"] = "Values"; + EType["Attribute"] = "Attribute"; + EType["Parameter"] = "Parameter"; + EType["Operation"] = "Operation"; + EType["ParameterOperation"] = "ParameterOperation"; + EType["Template"] = "Template"; + EType["Arguments"] = "Arguments"; +})(EType || (EType = {})); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2NoZW1hcy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxJQW9IWDtBQXBIRCxXQUFZLElBQUk7SUFDZjs7OztPQUlHO0lBQ0gsK0JBQWlCLENBQUE7SUFDakI7Ozs7T0FJRztJQUNILHFDQUFvQixDQUFBO0lBQ3BCOzs7O09BSUc7SUFDSCwrQ0FBeUIsQ0FBQTtJQUN6Qjs7OztPQUlHO0lBQ0gseURBQThCLENBQUE7SUFDOUI7Ozs7O09BS0c7SUFDSCw2RUFBd0MsQ0FBQTtJQUN4Qzs7OztPQUlHO0lBQ0gsb0NBQW1CLENBQUE7SUFDbkI7Ozs7T0FJRztJQUNILDhEQUFnQyxDQUFBO0lBQ2hDOzs7O09BSUc7SUFDSCwwREFBOEIsQ0FBQTtJQUM5Qjs7OztPQUlHO0lBQ0gsaUVBQWlDLENBQUE7SUFDakM7Ozs7T0FJRztJQUNILDJDQUFzQixDQUFBO0lBQ3RCOzs7O09BSUc7SUFDSCwrQ0FBd0IsQ0FBQTtJQUN4Qjs7OztPQUlHO0lBQ0gsd0NBQW9CLENBQUE7SUFDcEI7Ozs7T0FJRztJQUNILDhDQUF1QixDQUFBO0lBQ3ZCOzs7O09BSUc7SUFDSCw4Q0FBd0IsQ0FBQTtJQUN4Qjs7OztPQUlHO0lBQ0gsc0NBQW9CLENBQUE7SUFDcEI7Ozs7T0FJRztJQUNILGlEQUF5QixDQUFBO0lBQ3pCOzs7O09BSUc7SUFDSCxtQ0FBa0IsQ0FBQTtJQUNsQjs7OztPQUlHO0lBQ0gsaURBQXlCLENBQUE7SUFDekI7Ozs7T0FJRztJQUNILGtDQUFpQixDQUFBO0FBQ2xCLENBQUMsRUFwSFcsSUFBSSxLQUFKLElBQUksUUFvSGY7QUFFRCxNQUFNLENBQU4sSUFBWSxLQW9CWDtBQXBCRCxXQUFZLEtBQUs7SUFFYiwwQkFBaUIsQ0FBQTtJQUNqQiwwQkFBaUIsQ0FBQTtJQUNqQiw0QkFBbUIsQ0FBQTtJQUNuQixzQkFBYSxDQUFBO0lBQ2IsZ0NBQXVCLENBQUE7SUFDdkIsOEJBQXFCLENBQUE7SUFDckIsb0JBQVcsQ0FBQTtJQUNYLGlDQUF3QixDQUFBO0lBQ3hCLHdCQUFlLENBQUE7SUFDZiwwQkFBaUIsQ0FBQTtJQUNqQix3QkFBZSxDQUFBO0lBQ2YsMEJBQWlCLENBQUE7SUFDakIsZ0NBQXVCLENBQUE7SUFDdkIsZ0NBQXVCLENBQUE7SUFDdkIsZ0NBQXVCLENBQUE7SUFDdkIsa0RBQXlDLENBQUE7SUFDekMsOEJBQXFCLENBQUE7SUFDckIsZ0NBQXVCLENBQUE7QUFDM0IsQ0FBQyxFQXBCVyxLQUFLLEtBQUwsS0FBSyxRQW9CaEIifQ== \ No newline at end of file diff --git a/packages/commons/dist/schemas/vfs.d.ts b/packages/commons/dist/schemas/vfs.d.ts new file mode 100644 index 00000000..cb0ff5c3 --- /dev/null +++ b/packages/commons/dist/schemas/vfs.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/packages/commons/dist/schemas/vfs.js b/packages/commons/dist/schemas/vfs.js new file mode 100644 index 00000000..9adece09 --- /dev/null +++ b/packages/commons/dist/schemas/vfs.js @@ -0,0 +1,3 @@ +export {}; +//import { zodToJsonSchema } from "zod-to-json-schema" +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmZzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NjaGVtYXMvdmZzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxzREFBc0QifQ== \ No newline at end of file diff --git a/packages/commons/dist/schemas/zod_map.d.ts b/packages/commons/dist/schemas/zod_map.d.ts new file mode 100644 index 00000000..d6b6127a --- /dev/null +++ b/packages/commons/dist/schemas/zod_map.d.ts @@ -0,0 +1,46 @@ +import { ZodObject, ZodTypeAny } from 'zod'; +/** + * Manages a collection of Zod schema properties + * and combines them into a single Zod object schema. + * + * @template MetaType The type of metadata you want to store for each field. + * Defaults to Record if not provided. + */ +export declare class ZodMetaMap> { + private fieldMap; + /** + * Adds a Zod schema under a specific key (property name), + * optionally attaching typed metadata. + * + * @param key - The name of the property in the root object. + * @param schema - The Zod schema for that property. + * @param metadata - Optional metadata object (type MetaType). + */ + add(key: string, schema: T, metadata?: MetaType): this; + /** + * Builds and returns a root Zod object + * that combines all properties which were added. + */ + root(): ZodObject>; + /** + * Retrieves the metadata for a specific key, if any. + */ + getMetadata(key: string): MetaType | undefined; + /** + * Static factory method: creates a SchemaMetaManager + * while letting you optionally specify the MetaType. + * + * Usage: + * const manager = SchemaMetaManager.create(); + */ + static create>(): ZodMetaMap; + /** + * Returns a basic UiSchema object that RJSF can use to render form controls. + * + * - Adds a top-level "ui:submitButtonOptions" (example). + * - For each field, we set `ui:title` (uppercase key), + * `ui:description` (from Zod's .describe() if available), + * and a naive placeholder from the default value (if parse(undefined) succeeds). + */ + getUISchema(): Record; +} diff --git a/packages/commons/dist/schemas/zod_map.js b/packages/commons/dist/schemas/zod_map.js new file mode 100644 index 00000000..ee3f66d9 --- /dev/null +++ b/packages/commons/dist/schemas/zod_map.js @@ -0,0 +1,99 @@ +import { z } from 'zod'; +/** + * Manages a collection of Zod schema properties + * and combines them into a single Zod object schema. + * + * @template MetaType The type of metadata you want to store for each field. + * Defaults to Record if not provided. + */ +export class ZodMetaMap { + fieldMap = new Map(); + /** + * Adds a Zod schema under a specific key (property name), + * optionally attaching typed metadata. + * + * @param key - The name of the property in the root object. + * @param schema - The Zod schema for that property. + * @param metadata - Optional metadata object (type MetaType). + */ + add(key, schema, metadata) { + this.fieldMap.set(key, { schema, metadata }); + return this; + } + /** + * Builds and returns a root Zod object + * that combines all properties which were added. + */ + root() { + const shape = {}; + for (const [key, { schema }] of this.fieldMap.entries()) { + shape[key] = schema; + } + return z.object(shape); + } + /** + * Retrieves the metadata for a specific key, if any. + */ + getMetadata(key) { + return this.fieldMap.get(key)?.metadata; + } + /** + * Static factory method: creates a SchemaMetaManager + * while letting you optionally specify the MetaType. + * + * Usage: + * const manager = SchemaMetaManager.create(); + */ + static create() { + return new ZodMetaMap(); + } + /** + * Returns a basic UiSchema object that RJSF can use to render form controls. + * + * - Adds a top-level "ui:submitButtonOptions" (example). + * - For each field, we set `ui:title` (uppercase key), + * `ui:description` (from Zod's .describe() if available), + * and a naive placeholder from the default value (if parse(undefined) succeeds). + */ + getUISchema() { + // Start with some top-level UI schema config (optional) + const uiSchema = { + 'ui:submitButtonOptions': { + props: { + disabled: false, + className: 'btn btn-info', + }, + norender: false, + submitText: 'Submit', + }, + }; + for (const [key, { schema }] of this.fieldMap.entries()) { + let fieldUi = {}; + // Use the Zod description if available + // (Accessing `._def.description` is private/hacky, but commonly done.) + const sAny = schema; + if (sAny?._def?.description) { + fieldUi['ui:description'] = sAny._def.description; + } + // RJSF usually reads 'title' from JSON schema. But if you want + // to override it in UI schema, you can do so: + fieldUi['ui:title'] = key[0].toUpperCase() + key.substr(1).toLowerCase(); + // If the Zod schema allows a default, we can parse(undefined) to get it. + try { + const defaultVal = schema.parse(undefined); + // There's no official 'ui:default' in RJSF, but you could do a placeholder: + fieldUi['ui:placeholder'] = defaultVal; + } + catch { + // no default + } + fieldUi = { + ...fieldUi, + ...this.getMetadata(key), + }; + uiSchema[key] = fieldUi; + } + return uiSchema; + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/commons/src/schemas/index.ts b/packages/commons/src/schemas/index.ts new file mode 100644 index 00000000..e3873519 --- /dev/null +++ b/packages/commons/src/schemas/index.ts @@ -0,0 +1,211 @@ +import * as path from 'path' +import * as CLI from 'yargs' +import { z, ZodTypeAny, ZodObject, ZodEffects, ZodOptional, ZodDefault } from 'zod' +import { sync as writeFS } from '@polymech/fs/write' +import { zodToTs, printNode } from 'zod-to-ts' +import { zodToJsonSchema } from "zod-to-json-schema" +import { logger } from '@/logger.js' + +export * from './path.js' +export * from './zod_map.js' + +export const generate_interfaces = (schemas: ZodObject[], dst: string) => { + const types = schemas.map(schema => `export interface ${schema.description || 'IOptions'} ${printNode(zodToTs(schema).node)}`) + writeFS(dst, types.join('\n')) +} +export const enumerateHelpStrings = (schema: ZodTypeAny, path: string[] = [], logger: any): void => { + if (schema instanceof ZodObject) { + for (const key in schema.shape) { + const nestedSchema = schema.shape[key]; + enumerateHelpStrings(nestedSchema, [...path, key], logger) + } + } else { + const description = schema._def.description; + if (description) { + logger.debug(`\t ${path.join('.')}: ${description}`) + } + } +} +export const yargsDefaults = (yargs: CLI.Argv) => yargs.parserConfiguration({ "camel-case-expansion": false }) + +export const getInnerSchema = (schema: ZodTypeAny): ZodTypeAny => { + while (schema instanceof ZodEffects) { + schema = schema._def.schema + } + return schema +} +export const getInnerType = (type: ZodTypeAny) => { + while (type instanceof ZodOptional) { + type = type._def.innerType + } + while (type._def.typeName === 'ZodDefault' || type._def.typeName === 'ZodOptional') { + type = type._def.innerType; + } + return type._def.typeName +} +export const getDefaultValue = (schema: ZodTypeAny) => { + if (schema instanceof ZodDefault) { + return schema._def.defaultValue(); + } + return undefined; +} +export const getFieldDefaultValue = (schema: ZodTypeAny): any | undefined => { + if(!schema){ + return undefined + } + if (schema._def.typeName === 'ZodDefault') { + return schema._def.defaultValue(); + } + if (schema instanceof ZodOptional) { + return getFieldDefaultValue(schema.unwrap()); + } + if (schema instanceof ZodEffects) { + return getFieldDefaultValue(schema._def.schema); + } + if(typeof schema._def){ + return getFieldDefaultValue(schema._def.schema) + } + return undefined; + } +export const getDescription = (schema: ZodTypeAny): string | undefined =>{ + if(!schema){ + return undefined + } + if (schema._def.description) { + return schema._def.description; + } + if (schema instanceof ZodOptional) { + return getDescription(schema.unwrap()); + } + + if (schema instanceof ZodEffects) { + return getDescription(schema._def.schema); + } + + if(typeof schema._def){ + return getDescription(schema._def.schema) + } + return undefined; + } +export const toYargs = (yargs: CLI.Argv, zodSchema: ZodObject, options?: { + onKey?: (yargs: CLI.Argv, key: string, options:any) => any +}) => { + yargsDefaults(yargs) + try { + const shape = zodSchema.shape + for (const key in shape) { + const zodField = shape[key] as ZodTypeAny + const innerDef = getInnerSchema(zodField) + if (!innerDef) { + continue + } + let type: 'string' | 'boolean' | 'number' | undefined; + const inner_type = getInnerType(innerDef) + let descriptionExtra = '' + switch (inner_type) { + case 'ZodString': + type = 'string' + break + case 'ZodBoolean': + type = 'boolean' + break + case 'ZodNumber': + type = 'number' + break + case 'ZodOptional': + case 'ZodEnum': + type = getInnerType(innerDef) + if (innerDef._def.typeName === 'ZodEnum') { + descriptionExtra = `\n\t ${innerDef._def.values.join(' \n\t ')}` + } + break + } + const defaultValue = getFieldDefaultValue(zodField) + let handled = false + const args = { + type, + default: defaultValue, + describe: `${zodField._def.description || ''} ${descriptionExtra}`.trim() + } + if(options?.onKey){ + handled = options.onKey(yargs, key, args) + } + if(!handled){ + yargs.option(key,args) + } + } + return yargs + } catch (error) { + logger.error('Error processing schema:', error) + return yargs + } +} +///////////////////////////////////////////////////////// +// +// Schema Writers +// +const extension = (file: string) => path.parse(file).ext +const json = (data: any, file: string, name: string, options: {}) => writeFS(file, data.map((s) => zodToJsonSchema(s, name))) + +export const WRITERS = +{ + '.json': json +} + +export const writer = (file: string) => WRITERS[extension(file)] + +export const write = (schemas: ZodObject[], file: string, name: string, options: {}) => { + if (!WRITERS[extension(file)]) { + logger.error(`No writer found for file extension: ${extension(file)} : file: ${file}`) + return + } + logger.debug(`Writing schema to ${file} : ${name}`) + try { + writer(file)(schemas, file, name, options) + } catch (e) { + logger.trace(`Error writing schema to ${file} : ${name}`, e, e.stack, e.message) + } +} +//////////////////////////////////////////////////////////////////// +// +// Schema Combinators +export const combineValidatorsOr = (validators: z.ZodTypeAny[]) => { + return z.string().refine((value) => { + const errors = []; + const isValid = validators.some((validator) => { + try { + validator.parse(value) + return true; + } catch (err) { + errors.push(err.errors) + return false; + } + }); + if (!isValid) { + throw new z.ZodError(errors.flat()) + } + return true; + }, 'Invalid value for all provided validators') +} + +export const combineValidatorsOrUsingZod = (validators: z.ZodTypeAny[]) => { + return validators.reduce((acc, validator) => acc.or(validator)); +}; +export const combineValidatorsOrUsingZod2 = (validators: z.ZodTypeAny[]) => { + return validators.reduce((acc, validator) => { + return acc.or(validator).refine((value) => { + try { + acc.parse(value); + return true; + } catch (errAcc) { + try { + validator.parse(value); + return true; + } catch (errValidator) { + throw new z.ZodError([...errAcc.errors, ...errValidator.errors]); + } + } + }) + }) +} + diff --git a/packages/commons/src/schemas/openapi.ts b/packages/commons/src/schemas/openapi.ts new file mode 100644 index 00000000..64bb4de0 --- /dev/null +++ b/packages/commons/src/schemas/openapi.ts @@ -0,0 +1,20 @@ +/* +export const openapi = (data: ZodObject[], file: string, name: string, options: {}) => { + const registry = new OpenAPIRegistry() + data.forEach((s) => registry.register(s.description, s)) + const generator = new OpenApiGeneratorV3(registry.definitions) + const component = generator.generateComponents() + // const content = stringifyYAML(component) + return component +} +*/ +/* +const yaml = (data: ZodObject[], file: string, name: string, options: {}) => { + const registry = new OpenAPIRegistry() + data.forEach((s) => registry.register(s.description, s)) + const generator = new OpenApiGeneratorV3(registry.definitions) + const component = generator.generateComponents() + logger.debug(`Writing schema to ${file} : ${name}`,component) + writeFS(file,stringifyYAML(component)) +} +*/ \ No newline at end of file diff --git a/packages/commons/src/schemas/path.ts b/packages/commons/src/schemas/path.ts new file mode 100644 index 00000000..c7e73d14 --- /dev/null +++ b/packages/commons/src/schemas/path.ts @@ -0,0 +1,253 @@ +import { z, ZodTypeAny } from 'zod' +import * as path from 'path' +import { accessSync, constants, lstatSync, existsSync } from 'fs' + +import { isString } from '@polymech/core/primitives' +import { sync as exists } from '@polymech/fs/exists' +import { sync as read } from '@polymech/fs/read' + +import { logger } from '@/logger.js' +import { DEFAULT_VARS, resolve, template } from '@/variables.js' +import { getDescription } from '@/schemas/index.js' +import { isFile } from '@/lib/fs.js' + +type TResult = { resolved: string, source: string, value: unknown } +type TRefine = (src: string, ctx: any, variables: Record) => string | z.ZodNever +type TTransform = (src: string, variables?: Record) => string | TResult +type TExtend = { refine: Array, transform: Array } + +const DefaultPathSchemaBase = z.string().describe('Path to a file or directory') + +const PathErrorMessages = { + INVALID_INPUT: 'INVALID_INPUT: ${inputPath}', + PATH_DOES_NOT_EXIST: 'Path does not exist ${inputPath} = ${resolvedPath}', + DIRECTORY_NOT_WRITABLE: 'Directory is not writable ${inputPath} = ${resolvedPath}', + NOT_A_DIRECTORY: 'Path is not a directory or does not exist ${inputPath} = ${resolvedPath}', + NOT_A_JSON_FILE: 'File is not a JSON file or does not exist ${inputPath} = ${resolvedPath}', + PATH_NOT_ABSOLUTE: 'Path is not absolute ${inputPath} = ${resolvedPath}', + PATH_NOT_RELATIVE: 'Path is not relative ${inputPath} = ${resolvedPath}', +} as const + +export enum E_PATH { + ENSURE_PATH_EXISTS = 1, + INVALID_INPUT, + ENSURE_DIRECTORY_WRITABLE, + ENSURE_FILE_IS_JSON, + ENSURE_PATH_IS_ABSOLUTE, + ENSURE_PATH_IS_RELATIVE, + GET_PATH_INFO +} + +export const Transformers:Record = { + resolve: (val: string, variables: Record = {}) => { + if (!val) { + return null + } + return { + resolved: path.resolve(resolve(val, false, variables)), + source: val + } + }, + json: (val: string | { resolved: string, source: string }, variables: Record = {}) => { + if (!val) { + return null + } + const resolved = path.resolve(resolve(isString(val) ? val : val.source, false, variables)) + return { + resolved, + source: val, + value: read(resolved, 'json') + } + }, + string: (val: string | { resolved: string, source: string }, variables: Record = {}) => { + if (!val) { + return null + } + let src = isString(val) ? val : val.source + src = resolve(src, false, variables) + const resolved = path.resolve(src) + if (!exists(resolved) || !isFile(resolved)) { + return { + resolved, + source: val, + value: null + } + } + else { + let value = null + try { + value = read(resolved, 'string') + } catch (e) { + logger.error('Failed to read file', { resolved, source: val, error: e.message }) + } + return { + resolved, + source: val, + value + } + } + } +} + +export const TransformersDescription = [ + { + description: 'RESOLVE_PATH', + fn: Transformers.resolve + }, + { + description: 'READ_JSON', + fn: Transformers.json + }, + { + description: 'READ_STRING', + fn: Transformers.string + } +] +const extendType = (type: ZodTypeAny, extend: TExtend, variables: Record = {}) => { + if (Array.isArray(extend.refine)) { + for (const refine of extend.refine) { + type = type.refine(refine as any) + } + } else { + type = type.refine(extend.refine) + } + if (Array.isArray(extend.transform)) { + for (const transform of extend.transform) { + type = type.transform((val) => transform(val, variables)) + } + } else { + type = type.transform(extend.transform) + } + return type +} + +const extendTypeDescription = (type: ZodTypeAny, extension: TExtend, variables: Record = {}) => { + const description = getDescription(type) || '' + let transformerDescriptions = 'Transformers:\n' + if (Array.isArray(extension.transform)) { + for (const transform of extension.transform) { + transformerDescriptions += transformerDescription(transform) + '\n' + } + } else { + transformerDescriptions += transformerDescription(extension.transform) + '\n' + } + type = type.describe(description + '\n' + transformerDescriptions) + return type +} + +const transformerDescription = (fn: TTransform) => { + const description = TransformersDescription.find((t) => t.fn === fn) + return description ? description.description : 'Unknown' +} + +export const extendSchema = (baseSchema: z.ZodObject, extend: Record) => { + const baseShape = baseSchema.shape + const extendedShape: Record = { ...baseShape } + for (const [key, refines] of Object.entries(extend)) { + if (!baseShape[key]) + continue + + let fieldSchema = baseShape[key] + if (Array.isArray(refines.refine)) { + for (const refine of refines.refine) { + fieldSchema = fieldSchema.superRefine(refine) + } + } else { + fieldSchema = fieldSchema.superRefine(refines) + } + if (Array.isArray(refines.transform)) { + for (const transform of refines.transform) { + fieldSchema = fieldSchema.transform((val) => transform(val)) + } + } else { + fieldSchema = fieldSchema.transform(refines.transform) + } + extendedShape[key] = fieldSchema + + } + return z.object(extendedShape) +} + +export const ENSURE_DIRECTORY_WRITABLE = (inputPath: string, ctx: any, variables: Record) => { + const resolvedPath = path.resolve(resolve(inputPath, false, variables)) + const parts = path.parse(resolvedPath) + if (resolvedPath && existsSync(parts.dir) && lstatSync(parts.dir).isDirectory()) { + try { + accessSync(resolvedPath, constants.W_OK) + return resolvedPath + } catch (e) { + ctx.addIssue({ + code: E_PATH.ENSURE_DIRECTORY_WRITABLE, + message: template(PathErrorMessages.DIRECTORY_NOT_WRITABLE, { inputPath, resolvedPath }) + }) + return z.NEVER + } + } else { + ctx.addIssue({ + code: E_PATH.ENSURE_DIRECTORY_WRITABLE, + message: template(PathErrorMessages.NOT_A_DIRECTORY, { inputPath, resolvedPath }) + }) + return z.NEVER + } + +} + +export const IS_VALID_STRING = (inputPath: string) => isString(inputPath) + +export const ENSURE_PATH_EXISTS = (inputPath: string, ctx: any, variables: Record) => { + if (!inputPath || !ctx) { + return z.NEVER + } + if (!isString(inputPath)) { + ctx.addIssue({ + code: E_PATH.INVALID_INPUT, + message: template(PathErrorMessages.INVALID_INPUT, {}) + }) + return z.NEVER + } + const resolvedPath = path.resolve(resolve(inputPath, false, variables)) + if (!exists(resolvedPath)) { + ctx.addIssue({ + code: E_PATH.ENSURE_PATH_EXISTS, + message: template(PathErrorMessages.PATH_DOES_NOT_EXIST, { inputPath, resolvedPath }) + }) + + return z.NEVER + } + return resolvedPath +} + +export const test = () => { + const BaseCompilerOptions = () => z.object({ + root: DefaultPathSchemaBase.default(`${process.cwd()}`) + }) + const ret = extendSchema(BaseCompilerOptions(), { + root: { + refine: [ + (val, ctx) => ENSURE_DIRECTORY_WRITABLE(val, ctx, DEFAULT_VARS({ exampleVar: 'exampleValue' })), + (val, ctx) => ENSURE_PATH_EXISTS(val, ctx, DEFAULT_VARS({ exampleVar: 'exampleValue' })) + ], + transform: [ + (val) => path.resolve(resolve(val, false, DEFAULT_VARS({ exampleVar: 'exampleValue' }))) + ] + } + }) + return ret +} + +export const Templates:Record = +{ + json: { + refine: [IS_VALID_STRING, ENSURE_PATH_EXISTS], + transform: [Transformers.resolve, Transformers.json] + }, + string: { + refine: [ENSURE_PATH_EXISTS], + transform: [Transformers.resolve, Transformers.string] + } +} + +export const extend = (baseSchema: ZodTypeAny, template: any, variables: Record = {}) => { + const type = extendType(baseSchema, template, variables) + return extendTypeDescription(type, template, variables) +} diff --git a/packages/commons/src/schemas/types.ts b/packages/commons/src/schemas/types.ts new file mode 100644 index 00000000..25d974b3 --- /dev/null +++ b/packages/commons/src/schemas/types.ts @@ -0,0 +1,187 @@ +export enum FLAG { + /** + * Instruct for no additional extra processing + * @constant + * @type int + */ + NONE = 0x00000000, + /** + * Will instruct the pre/post processor to base-64 decode or encode + * @constant + * @type int + */ + BASE_64 = 0x00000001, + /** + * Post/Pre process the value with a user function + * @constant + * @type int + */ + USE_FUNCTION = 0x00000002, + /** + * Replace variables with local scope's variables during the post/pre process + * @constant + * @type int + */ + REPLACE_VARIABLES = 0x00000004, + /** + * Replace variables with local scope's variables during the post/pre process but evaluate the whole string + * as Javascript + * @constant + * @type int + */ + REPLACE_VARIABLES_EVALUATED = 0x00000008, + /** + * Will instruct the pre/post processor to escpape evaluated or replaced variables or expressions + * @constant + * @type int + */ + ESCAPE = 0x00000010, + /** + * Will instruct the pre/post processor to replace block calls with oridinary vanilla script + * @constant + * @type int + */ + REPLACE_BLOCK_CALLS = 0x00000020, + /** + * Will instruct the pre/post processor to remove variable delimitters/placeholders from the final string + * @constant + * @type int + */ + REMOVE_DELIMTTERS = 0x00000040, + /** + * Will instruct the pre/post processor to remove "[" ,"]" , "(" , ")" , "{", "}" , "*" , "+" , "." + * @constant + * @type int + */ + ESCAPE_SPECIAL_CHARS = 0x00000080, + /** + * Will instruct the pre/post processor to use regular expressions over string substitution + * @constant + * @type int + */ + USE_REGEX = 0x00000100, + /** + * Will instruct the pre/post processor to use Filtrex (custom bison parser, needs xexpression) over string substitution + * @constant + * @type int + */ + USE_FILTREX = 0x00000200, + /** + * Cascade entry. There are cases where #USE_FUNCTION is not enough or we'd like to avoid further type checking. + * @constant + * @type int + */ + CASCADE = 0x00000400, + /** + * Cascade entry. There are cases where #USE_FUNCTION is not enough or we'd like to avoid further type checking. + * @constant + * @type int + */ + EXPRESSION = 0x00000800, + /** + * Dont parse anything + * @constant + * @type int + */ + DONT_PARSE = 0x000001000, + /** + * Convert to hex + * @constant + * @type int + */ + TO_HEX = 0x000002000, + /** + * Convert to hex + * @constant + * @type int + */ + REPLACE_HEX = 0x000004000, + /** + * Wait for finish + * @constant + * @type int + */ + WAIT = 0x000008000, + /** + * Wait for finish + * @constant + * @type int + */ + DONT_ESCAPE = 0x000010000, + /** + * Flag to mark the maximum core bit mask, after here its user land + * @constant + * @type int + */ + END = 0x000020000 +} + +export enum EType +{ + Number = 'Number', + String = 'String', + Boolean = 'Boolean', + Date = 'Date', + TimeStamp = 'TimeStamp', + Duration = 'Duration', + Url = 'Url', + UrlScheme = 'Url-Scheme', + Asset = 'Asset', + Symbol = 'Symbol', + Value = 'Value', + Values = 'Values', + Attribute = 'Attribute', + Parameter = 'Parameter', + Operation = 'Operation', + ParameterOperation = 'ParameterOperation', + Template = 'Template', + Arguments = 'Arguments' +} +export type TVector2D = [number, number]; +export type TVector3D = [number, number, number]; +export type TBBox = [TVector3D, TVector3D]; +export type TQuaternion = [number, number, number, number]; +export type TFlags = Record; +export type TExpression = string | [string | RegExp, { [key: string]: any }]; +export type TOptions = { flags?: TFlags | { [key: string]: any } }; + +export interface IUrlScheme { + url: string; + options?: { [key: string]: any }; +} + +export interface IAsset { + urlScheme: IUrlScheme; + options?: { [key: string]: any }; +} + +export type TSelector = TExpression | [TExpression, { [key: string]: any }]; + +export interface ITypeInfo { + type: string; + symbol: bigint; +} + +export interface IRef { + key: string | string; + struct: { [key: string]: any }; +} + +export interface IAttribute { + type: ITypeInfo; + value: bigint; +} + +export interface IParameter { + type: ITypeInfo; + value: bigint; +} + +export interface IParameterOperation { + param1: bigint; + param2: bigint; + operation: bigint; +} + +export type TTemplate = string | [ITypeInfo | TSelector, { [key: string]: any }]; +export type TArguments = { [key: string]: any } | any[]; diff --git a/packages/commons/src/schemas/vfs.ts b/packages/commons/src/schemas/vfs.ts new file mode 100644 index 00000000..b644c02f --- /dev/null +++ b/packages/commons/src/schemas/vfs.ts @@ -0,0 +1 @@ +//import { zodToJsonSchema } from "zod-to-json-schema" diff --git a/packages/commons/src/schemas/zod_map.ts b/packages/commons/src/schemas/zod_map.ts new file mode 100644 index 00000000..a152d2e1 --- /dev/null +++ b/packages/commons/src/schemas/zod_map.ts @@ -0,0 +1,109 @@ +import { z, ZodObject, ZodTypeAny } from 'zod'; + +/** + * Manages a collection of Zod schema properties + * and combines them into a single Zod object schema. + * + * @template MetaType The type of metadata you want to store for each field. + * Defaults to Record if not provided. + */ +export class ZodMetaMap> { + private fieldMap = new Map< + string, + { schema: ZodTypeAny; metadata?: MetaType } + >(); + + /** + * Adds a Zod schema under a specific key (property name), + * optionally attaching typed metadata. + * + * @param key - The name of the property in the root object. + * @param schema - The Zod schema for that property. + * @param metadata - Optional metadata object (type MetaType). + */ + add(key: string, schema: T, metadata?: MetaType): this { + this.fieldMap.set(key, { schema, metadata }); + return this; + } + + /** + * Builds and returns a root Zod object + * that combines all properties which were added. + */ + root(): ZodObject> { + const shape: Record = {}; + for (const [key, { schema }] of this.fieldMap.entries()) { + shape[key] = schema; + } + return z.object(shape); + } + + /** + * Retrieves the metadata for a specific key, if any. + */ + getMetadata(key: string): MetaType | undefined { + return this.fieldMap.get(key)?.metadata; + } + + /** + * Static factory method: creates a SchemaMetaManager + * while letting you optionally specify the MetaType. + * + * Usage: + * const manager = SchemaMetaManager.create(); + */ + static create>(): ZodMetaMap { + return new ZodMetaMap(); + } + + /** + * Returns a basic UiSchema object that RJSF can use to render form controls. + * + * - Adds a top-level "ui:submitButtonOptions" (example). + * - For each field, we set `ui:title` (uppercase key), + * `ui:description` (from Zod's .describe() if available), + * and a naive placeholder from the default value (if parse(undefined) succeeds). + */ + getUISchema(): Record { + // Start with some top-level UI schema config (optional) + const uiSchema: Record = { + 'ui:submitButtonOptions': { + props: { + disabled: false, + className: 'btn btn-info', + }, + norender: false, + submitText: 'Submit', + }, + }; + + for (const [key, { schema }] of this.fieldMap.entries()) { + let fieldUi: Record = { }; + // Use the Zod description if available + // (Accessing `._def.description` is private/hacky, but commonly done.) + const sAny = schema as any; + if (sAny?._def?.description) { + fieldUi['ui:description'] = sAny._def.description; + } + + // RJSF usually reads 'title' from JSON schema. But if you want + // to override it in UI schema, you can do so: + fieldUi['ui:title'] = key[0].toUpperCase() + key.substr(1).toLowerCase() + + // If the Zod schema allows a default, we can parse(undefined) to get it. + try { + const defaultVal = schema.parse(undefined); + // There's no official 'ui:default' in RJSF, but you could do a placeholder: + fieldUi['ui:placeholder'] = defaultVal; + } catch { + // no default + } + fieldUi = { + ...fieldUi, + ...this.getMetadata(key), + } + uiSchema[key] = fieldUi; + } + return uiSchema; + } +} \ No newline at end of file