@finsys/core 1.0.0 → 1.1.0

package/README.md

@@ -215,6 +215,16 @@ npm run lint     # Type-check without emitting
 
 See [CONTRIBUTING.md](./CONTRIBUTING.md).
 
+## Security
+
+### Expression Evaluation
+
+The `evaluateExpression()` function uses `new Function()` internally to evaluate SurveyJS-style visibility expressions. Expression strings **must come from trusted, developer-authored sources** (e.g., your own form configuration files). Never pass untrusted or user-supplied strings as expressions, as this could allow arbitrary code execution.
+
+## Disclaimer
+
+This library provides form configuration utilities and does not constitute financial, legal, or investment advice. It does not perform financial calculations, risk assessments, or lending decisions. The creators and contributors accept no liability for decisions made using forms generated by this library. See the [LICENSE](./LICENSE) file for warranty and liability terms.
+
 ## License
 
 [Apache-2.0](./LICENSE)

package/dist/catalogs.d.ts

@@ -0,0 +1,13 @@
+import type { FieldData, Category } from "./survey-generator.js";
+import type { FormFieldTypeDefinitions } from "./form-field.js";
+import type { FormValidatorDefinitions } from "./form-field-validator.js";
+export declare const BASE_FIELD_SPECS: {
+    schemaVersion: string;
+    categories: Category[];
+    fields: FieldData[];
+};
+export declare const FIELD_TYPE_DEFINITIONS: FormFieldTypeDefinitions;
+export declare const DEFAULT_VALIDATOR_DEFINITIONS: FormValidatorDefinitions;
+export declare function getBaseFieldSpecs(): FieldData[];
+export declare function getBaseCategories(): Category[];
+export declare function getBaseFieldNames(): string[];

package/dist/catalogs.js

@@ -0,0 +1,35 @@
+import FormField from "./form-field.js";
+import baseSpecsData from "./data/form-field-base-specs.json" with { type: "json" };
+import typeDefsData from "./data/form-field-types.json" with { type: "json" };
+import validatorDefsData from "./data/form-field-validators.json" with { type: "json" };
+export const BASE_FIELD_SPECS = baseSpecsData;
+export const FIELD_TYPE_DEFINITIONS = typeDefsData;
+export const DEFAULT_VALIDATOR_DEFINITIONS = {
+    version: validatorDefsData.version,
+    options: validatorDefsData.options,
+};
+export function getBaseFieldSpecs() {
+    return BASE_FIELD_SPECS.fields;
+}
+export function getBaseCategories() {
+    return BASE_FIELD_SPECS.categories;
+}
+let cachedFieldNames = null;
+export function getBaseFieldNames() {
+    if (cachedFieldNames) {
+        return cachedFieldNames;
+    }
+    const fields = BASE_FIELD_SPECS.fields;
+    const names = [];
+    for (const field of fields) {
+        try {
+            const formField = FormField.fromObject(field);
+            names.push(...formField.getFieldNames());
+        }
+        catch {
+            // Skip fields that fail to parse
+        }
+    }
+    cachedFieldNames = [...new Set(names)];
+    return cachedFieldNames;
+}

package/dist/catalogs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/catalogs.test.js

@@ -0,0 +1,207 @@
+import { describe, it, expect } from "vitest";
+import { generateRHFSchema } from "./rhf-generator.js";
+import { BASE_FIELD_SPECS, FIELD_TYPE_DEFINITIONS, DEFAULT_VALIDATOR_DEFINITIONS, getBaseFieldSpecs, getBaseCategories, getBaseFieldNames, } from "./catalogs.js";
+describe("BASE_FIELD_SPECS", () => {
+    it("has schemaVersion, categories, and fields", () => {
+        expect(BASE_FIELD_SPECS.schemaVersion).toBeDefined();
+        expect(Array.isArray(BASE_FIELD_SPECS.categories)).toBe(true);
+        expect(Array.isArray(BASE_FIELD_SPECS.fields)).toBe(true);
+        expect(BASE_FIELD_SPECS.categories.length).toBeGreaterThan(0);
+        expect(BASE_FIELD_SPECS.fields.length).toBeGreaterThan(0);
+    });
+});
+describe("FIELD_TYPE_DEFINITIONS", () => {
+    it("has version, types, and input_types", () => {
+        expect(FIELD_TYPE_DEFINITIONS.version).toBeDefined();
+        expect(Array.isArray(FIELD_TYPE_DEFINITIONS.types)).toBe(true);
+        expect(Array.isArray(FIELD_TYPE_DEFINITIONS.input_types)).toBe(true);
+        expect(FIELD_TYPE_DEFINITIONS.types.length).toBeGreaterThan(0);
+        expect(FIELD_TYPE_DEFINITIONS.input_types.length).toBeGreaterThan(0);
+    });
+});
+describe("DEFAULT_VALIDATOR_DEFINITIONS", () => {
+    it("has version and options", () => {
+        expect(DEFAULT_VALIDATOR_DEFINITIONS.version).toBeDefined();
+        expect(Array.isArray(DEFAULT_VALIDATOR_DEFINITIONS.options)).toBe(true);
+        expect(DEFAULT_VALIDATOR_DEFINITIONS.options.length).toBeGreaterThan(0);
+    });
+});
+describe("getBaseFieldSpecs", () => {
+    it("returns field array", () => {
+        const fields = getBaseFieldSpecs();
+        expect(Array.isArray(fields)).toBe(true);
+        expect(fields.length).toBeGreaterThan(0);
+        expect(fields[0].name).toBeDefined();
+        expect(fields[0].type).toBeDefined();
+    });
+});
+describe("getBaseCategories", () => {
+    it("returns category array", () => {
+        const categories = getBaseCategories();
+        expect(Array.isArray(categories)).toBe(true);
+        expect(categories.length).toBeGreaterThan(0);
+        expect(categories[0].id).toBeDefined();
+        expect(categories[0].name).toBeDefined();
+    });
+});
+describe("getBaseFieldNames", () => {
+    it("returns unique field names", () => {
+        const names = getBaseFieldNames();
+        expect(Array.isArray(names)).toBe(true);
+        expect(names.length).toBeGreaterThan(0);
+        // Should be unique
+        expect(new Set(names).size).toBe(names.length);
+    });
+});
+describe("Base Specs Zod Validation", () => {
+    it("all field definitions should be valid for RHF schema generation", () => {
+        const fields = BASE_FIELD_SPECS.fields;
+        const categories = BASE_FIELD_SPECS.categories;
+        const failedFields = [];
+        fields.forEach((field) => {
+            try {
+                const config = {
+                    schemaVersion: "v2.0.0",
+                    displayName: "Test",
+                    categories: categories,
+                    fields: {
+                        [field.name]: field,
+                    },
+                    pages: [
+                        {
+                            id: "test-page",
+                            fields: [field.name],
+                        },
+                    ],
+                };
+                const { zodSchema, defaultValues } = generateRHFSchema(config);
+                const result = zodSchema.safeParse(defaultValues);
+                if (!result.success) {
+                    const hasRequirementError = result.error.issues.some((i) => i.message === "This field is required" || i.code === "too_small");
+                    const isRequired = field.isRequired !== false && field.required !== false;
+                    if (!(isRequired && hasRequirementError && !field.defaultValue)) {
+                        failedFields.push({
+                            name: field.name,
+                            error: `Validation failed: ${JSON.stringify(result.error.issues)}`,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                failedFields.push({
+                    name: field.name,
+                    error: `Exception: ${error.message}`,
+                });
+            }
+        });
+        if (failedFields.length > 0) {
+            const errorMsg = failedFields.map((f) => `[${f.name}]: ${f.error}`).join("\n");
+            expect.unreachable(`Found ${failedFields.length} invalid field definitions:\n${errorMsg.substring(0, 2000)}`);
+        }
+    });
+});
+describe("Field Types Zod Validation", () => {
+    it("all supported type combinations should be valid for RHF schema generation", () => {
+        const types = FIELD_TYPE_DEFINITIONS.types;
+        const inputTypes = FIELD_TYPE_DEFINITIONS.input_types;
+        const failedCombinations = [];
+        for (const typeObj of types) {
+            const baseType = typeObj.name;
+            const targetInputTypes = baseType === "text" ? inputTypes : [{ name: undefined }];
+            for (const inputTypeObj of targetInputTypes) {
+                const inputType = inputTypeObj.name;
+                try {
+                    const field = {
+                        name: "testField",
+                        displayName: "Test Field",
+                        category: "1",
+                        type: baseType,
+                    };
+                    if (inputType)
+                        field.inputType = inputType;
+                    const config = {
+                        schemaVersion: "v2.0.0",
+                        displayName: "Test",
+                        categories: [{ id: "1", name: "Test" }],
+                        fields: { [field.name]: field },
+                        pages: [{ id: "test-page", fields: [field.name] }],
+                    };
+                    const { zodSchema, defaultValues } = generateRHFSchema(config);
+                    const result = zodSchema.safeParse(defaultValues);
+                    if (!result.success) {
+                        const errors = result.error.issues.filter((i) => i.message !== "This field is required" && i.code !== "too_small");
+                        if (errors.length > 0) {
+                            failedCombinations.push({
+                                type: baseType,
+                                inputType,
+                                error: `Validation failed: ${JSON.stringify(errors)}`,
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    failedCombinations.push({
+                        type: baseType,
+                        inputType,
+                        error: `Exception: ${error.message}`,
+                    });
+                }
+            }
+        }
+        if (failedCombinations.length > 0) {
+            const errorMsg = failedCombinations
+                .map((c) => `[${c.type}${c.inputType ? "/" + c.inputType : ""}]: ${c.error}`)
+                .join("\n");
+            expect.unreachable(`Found ${failedCombinations.length} invalid type combinations:\n${errorMsg}`);
+        }
+    });
+});
+describe("Field Validators Zod Validation", () => {
+    it("all shared validator definitions should be valid for RHF schema generation", () => {
+        const options = DEFAULT_VALIDATOR_DEFINITIONS.options;
+        const failedValidators = [];
+        options.forEach((option) => {
+            try {
+                const field = {
+                    name: "testField",
+                    displayName: "Test Field",
+                    category: "1",
+                    type: "text",
+                    validators: option.validators || [],
+                };
+                if (option.validators?.some((v) => v.type === "numeric")) {
+                    field.type = "number";
+                    field.inputType = "number";
+                }
+                const config = {
+                    schemaVersion: "v2.0.0",
+                    displayName: "Test",
+                    categories: [{ id: "1", name: "Test" }],
+                    fields: { [field.name]: field },
+                    pages: [{ id: "test-page", fields: [field.name] }],
+                };
+                const { zodSchema, defaultValues } = generateRHFSchema(config);
+                const result = zodSchema.safeParse(defaultValues);
+                if (!result.success) {
+                    const errors = result.error.issues.filter((i) => i.message !== "This field is required");
+                    if (errors.length > 0) {
+                        failedValidators.push({
+                            name: option.displayName,
+                            error: `Validation failed: ${JSON.stringify(errors)}`,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                failedValidators.push({
+                    name: option.displayName,
+                    error: `Exception: ${error.message}`,
+                });
+            }
+        });
+        if (failedValidators.length > 0) {
+            const errorMsg = failedValidators.map((f) => `[${f.name}]: ${f.error}`).join("\n");
+            expect.unreachable(`Found ${failedValidators.length} invalid validator definitions:\n${errorMsg.substring(0, 2000)}`);
+        }
+    });
+});