@gridfox/codegen 0.2.0

package/dist/model/zodSchemas.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+export declare const GRIDFOX_FIELD_TYPES: readonly ["text", "email", "textArea", "richText", "user", "number", "money", "percentage", "formula", "autoCounter", "checkbox", "date", "dateTime", "list", "multiSelectList", "parent", "child", "manyToMany", "file", "image"];
+export declare const GridfoxFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        number: "number";
+        text: "text";
+        email: "email";
+        textArea: "textArea";
+        richText: "richText";
+        user: "user";
+        money: "money";
+        percentage: "percentage";
+        formula: "formula";
+        autoCounter: "autoCounter";
+        checkbox: "checkbox";
+        date: "date";
+        dateTime: "dateTime";
+        list: "list";
+        multiSelectList: "multiSelectList";
+        parent: "parent";
+        child: "child";
+        manyToMany: "manyToMany";
+        file: "file";
+        image: "image";
+    }>;
+    isRequired: z.ZodOptional<z.ZodBoolean>;
+    isUnique: z.ZodOptional<z.ZodBoolean>;
+    properties: z.ZodOptional<z.ZodObject<{
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        relatedTableName: z.ZodOptional<z.ZodString>;
+        formulaType: z.ZodOptional<z.ZodString>;
+        currency: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const GridfoxTableSchema: z.ZodObject<{
+    name: z.ZodString;
+    singularName: z.ZodString;
+    referenceFieldName: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            text: "text";
+            email: "email";
+            textArea: "textArea";
+            richText: "richText";
+            user: "user";
+            money: "money";
+            percentage: "percentage";
+            formula: "formula";
+            autoCounter: "autoCounter";
+            checkbox: "checkbox";
+            date: "date";
+            dateTime: "dateTime";
+            list: "list";
+            multiSelectList: "multiSelectList";
+            parent: "parent";
+            child: "child";
+            manyToMany: "manyToMany";
+            file: "file";
+            image: "image";
+        }>;
+        isRequired: z.ZodOptional<z.ZodBoolean>;
+        isUnique: z.ZodOptional<z.ZodBoolean>;
+        properties: z.ZodOptional<z.ZodObject<{
+            items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            relatedTableName: z.ZodOptional<z.ZodString>;
+            formulaType: z.ZodOptional<z.ZodString>;
+            currency: z.ZodOptional<z.ZodString>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GridfoxTablesSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    singularName: z.ZodString;
+    referenceFieldName: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            text: "text";
+            email: "email";
+            textArea: "textArea";
+            richText: "richText";
+            user: "user";
+            money: "money";
+            percentage: "percentage";
+            formula: "formula";
+            autoCounter: "autoCounter";
+            checkbox: "checkbox";
+            date: "date";
+            dateTime: "dateTime";
+            list: "list";
+            multiSelectList: "multiSelectList";
+            parent: "parent";
+            child: "child";
+            manyToMany: "manyToMany";
+            file: "file";
+            image: "image";
+        }>;
+        isRequired: z.ZodOptional<z.ZodBoolean>;
+        isUnique: z.ZodOptional<z.ZodBoolean>;
+        properties: z.ZodOptional<z.ZodObject<{
+            items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            relatedTableName: z.ZodOptional<z.ZodString>;
+            formulaType: z.ZodOptional<z.ZodString>;
+            currency: z.ZodOptional<z.ZodString>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;

package/dist/model/zodSchemas.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export const GRIDFOX_FIELD_TYPES = [
+    'text',
+    'email',
+    'textArea',
+    'richText',
+    'user',
+    'number',
+    'money',
+    'percentage',
+    'formula',
+    'autoCounter',
+    'checkbox',
+    'date',
+    'dateTime',
+    'list',
+    'multiSelectList',
+    'parent',
+    'child',
+    'manyToMany',
+    'file',
+    'image'
+];
+const GridfoxFieldTypeSchema = z.enum(GRIDFOX_FIELD_TYPES);
+const FieldPropertiesSchema = z
+    .object({
+    items: z.array(z.object({ value: z.string(), color: z.string().nullable().optional() })).optional(),
+    relatedTableName: z.string().optional(),
+    formulaType: z.string().optional(),
+    currency: z.string().optional()
+})
+    .catchall(z.unknown())
+    .optional();
+export const GridfoxFieldSchema = z.object({
+    name: z.string().min(1),
+    type: GridfoxFieldTypeSchema,
+    isRequired: z.boolean().optional(),
+    isUnique: z.boolean().optional(),
+    properties: FieldPropertiesSchema
+});
+export const GridfoxTableSchema = z.object({
+    name: z.string().min(1),
+    singularName: z.string().min(1),
+    referenceFieldName: z.string().min(1),
+    fields: z.array(GridfoxFieldSchema)
+});
+export const GridfoxTablesSchema = z.array(GridfoxTableSchema);

package/dist/naming/fieldAliases.d.ts

@@ -0,0 +1 @@
+export declare const normalizeFieldAlias: (fieldName: string) => string;

package/dist/naming/fieldAliases.js

@@ -0,0 +1,3 @@
+import { camelCase } from 'change-case';
+import { safeIdentifier } from './reservedWords.js';
+export const normalizeFieldAlias = (fieldName) => safeIdentifier(camelCase(fieldName));

package/dist/naming/identifiers.d.ts

@@ -0,0 +1 @@
+export declare const ensureIdentifier: (value: string, fallbackPrefix: string) => string;

package/dist/naming/identifiers.js

@@ -0,0 +1,11 @@
+const identifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+export const ensureIdentifier = (value, fallbackPrefix) => {
+    const trimmed = value.trim().replace(/[^A-Za-z0-9_$]/g, '');
+    if (!trimmed) {
+        return fallbackPrefix;
+    }
+    if (identifierPattern.test(trimmed)) {
+        return trimmed;
+    }
+    return `${fallbackPrefix}${trimmed}`;
+};

package/dist/naming/reservedWords.d.ts

@@ -0,0 +1 @@
+export declare const safeIdentifier: (value: string) => string;

package/dist/naming/reservedWords.js

@@ -0,0 +1,13 @@
+const reserved = new Set([
+    'default',
+    'delete',
+    'class',
+    'function',
+    'return',
+    'import',
+    'export',
+    'var',
+    'let',
+    'const'
+]);
+export const safeIdentifier = (value) => reserved.has(value) ? `${value}Field` : value;

package/dist/naming/tableNames.d.ts

@@ -0,0 +1 @@
+export declare const normalizeTableSymbol: (tableName: string) => string;

package/dist/naming/tableNames.js

@@ -0,0 +1,3 @@
+import { pascalCase } from 'change-case';
+import { ensureIdentifier } from './identifiers.js';
+export const normalizeTableSymbol = (tableName) => ensureIdentifier(pascalCase(tableName), 'Table');

package/dist/typing/mapFieldType.d.ts

@@ -0,0 +1,8 @@
+import type { RawField } from '../model/internalTypes.js';
+export declare const listUnionType: (values: string[]) => string;
+interface TypeMappingOptions {
+    multiSelectMode?: 'union' | 'stringArray';
+}
+export declare const mapReadType: (field: RawField, mappingOptions?: TypeMappingOptions) => string;
+export declare const mapWriteType: (field: RawField, mappingOptions?: TypeMappingOptions) => string;
+export {};

package/dist/typing/mapFieldType.js

@@ -0,0 +1,95 @@
+const quote = (v) => JSON.stringify(v);
+export const listUnionType = (values) => values.map(quote).join(' | ');
+const numericFormulaTypes = new Set(['number', 'money', 'percentage', 'autocounter']);
+const mapFormulaReadType = (field) => {
+    const formulaType = field.properties?.formulaType;
+    if (!formulaType) {
+        return 'number | string | null';
+    }
+    if (numericFormulaTypes.has(formulaType.toLowerCase())) {
+        return 'number | null';
+    }
+    return 'string | null';
+};
+export const mapReadType = (field, mappingOptions = {}) => {
+    const listOptions = field.properties?.items?.map((item) => item.value) ?? [];
+    const multiSelectMode = mappingOptions.multiSelectMode ?? 'union';
+    switch (field.type) {
+        case 'text':
+        case 'email':
+        case 'textArea':
+        case 'richText':
+        case 'user':
+        case 'date':
+        case 'dateTime':
+            return 'string | null';
+        case 'number':
+        case 'money':
+        case 'percentage':
+        case 'autoCounter':
+            return 'number | null';
+        case 'formula':
+            return mapFormulaReadType(field);
+        case 'checkbox':
+            return 'boolean | null';
+        case 'list':
+            return listOptions.length ? `${listUnionType(listOptions)} | null` : 'string | null';
+        case 'multiSelectList':
+            if (multiSelectMode === 'stringArray') {
+                return 'string[] | null';
+            }
+            return listOptions.length ? `(${listUnionType(listOptions)})[] | null` : 'string[] | null';
+        case 'parent':
+            return 'GridfoxLinkedValue | null';
+        case 'child':
+        case 'manyToMany':
+            return 'GridfoxLinkedValue[] | null';
+        case 'file':
+            return 'GridfoxFileValue[] | null';
+        case 'image':
+            return 'GridfoxImageValue | null';
+        default:
+            return 'unknown';
+    }
+};
+export const mapWriteType = (field, mappingOptions = {}) => {
+    const listOptions = field.properties?.items?.map((item) => item.value) ?? [];
+    const multiSelectMode = mappingOptions.multiSelectMode ?? 'union';
+    switch (field.type) {
+        case 'formula':
+        case 'autoCounter':
+        case 'child':
+            return 'never';
+        case 'list':
+            return listOptions.length ? listUnionType(listOptions) : 'string';
+        case 'multiSelectList':
+            if (multiSelectMode === 'stringArray') {
+                return 'string[]';
+            }
+            return listOptions.length ? `(${listUnionType(listOptions)})[]` : 'string[]';
+        case 'parent':
+            return 'GridfoxLinkedValue';
+        case 'manyToMany':
+            return 'GridfoxLinkedValue[]';
+        case 'file':
+            return 'GridfoxFileValue[]';
+        case 'image':
+            return 'GridfoxImageValue';
+        case 'text':
+        case 'email':
+        case 'textArea':
+        case 'richText':
+        case 'user':
+        case 'date':
+        case 'dateTime':
+            return 'string';
+        case 'number':
+        case 'money':
+        case 'percentage':
+            return 'number';
+        case 'checkbox':
+            return 'boolean';
+        default:
+            return 'unknown';
+    }
+};

package/dist/typing/writability.d.ts

@@ -0,0 +1 @@
+export declare const isWritableFieldType: (kind: string) => boolean;

package/dist/typing/writability.js

@@ -0,0 +1,2 @@
+const readonlyKinds = new Set(['autoCounter', 'formula', 'child']);
+export const isWritableFieldType = (kind) => !readonlyKinds.has(kind);

package/dist/utils/sort.d.ts

@@ -0,0 +1,11 @@
+export declare const compareText: (left: string, right: string) => number;
+export declare const sortByName: <T extends {
+    name: string;
+}>(items: T[]) => T[];
+export declare const sortByFieldName: <T extends {
+    fieldName: string;
+}>(items: T[]) => T[];
+export declare const sortByTableName: <T extends {
+    tableName: string;
+}>(items: T[]) => T[];
+export declare const sortedKeys: <T>(record: Record<string, T>) => string[];

package/dist/utils/sort.js

@@ -0,0 +1,5 @@
+export const compareText = (left, right) => left.localeCompare(right);
+export const sortByName = (items) => [...items].sort((left, right) => compareText(left.name, right.name));
+export const sortByFieldName = (items) => [...items].sort((left, right) => compareText(left.fieldName, right.fieldName));
+export const sortByTableName = (items) => [...items].sort((left, right) => compareText(left.tableName, right.tableName));
+export const sortedKeys = (record) => Object.keys(record).sort(compareText);

package/dist/validate/crudPlan.d.ts

@@ -0,0 +1,23 @@
+import type { GridfoxFieldType, RawTable } from '../model/internalTypes.js';
+export type CrudPrimitive = string | number | boolean | null;
+export type CrudArray = CrudPrimitive[];
+export type CrudValue = CrudPrimitive | CrudArray;
+export type CrudPayload = Record<string, CrudValue>;
+export interface CrudPlan {
+    tableName: string;
+    referenceFieldName: string;
+    createPayload: CrudPayload;
+    updatePayload: CrudPayload;
+    verifyAfterCreate: CrudPayload;
+    verifyAfterUpdate: CrudPayload;
+    rationale?: string;
+}
+export interface ExecutableCrudPlan extends CrudPlan {
+    referenceFieldType: GridfoxFieldType;
+}
+interface BuildHeuristicPlanOptions {
+    tableName?: string;
+    runId?: string;
+}
+export declare const buildHeuristicPlan: (tables: RawTable[], options?: BuildHeuristicPlanOptions) => ExecutableCrudPlan;
+export {};

package/dist/validate/crudPlan.js

@@ -0,0 +1,189 @@
+import { sortByName } from '../utils/sort.js';
+import { isWritableFieldType } from '../typing/writability.js';
+const stringLikeReferenceTypes = new Set(['text', 'email', 'textArea', 'richText', 'user']);
+const scalarWritableTypes = new Set([
+    'text',
+    'email',
+    'textArea',
+    'richText',
+    'user',
+    'number',
+    'money',
+    'percentage',
+    'checkbox',
+    'date',
+    'dateTime',
+    'list',
+    'multiSelectList'
+]);
+const uniqueValueSafeTypes = new Set([
+    'text',
+    'email',
+    'textArea',
+    'richText',
+    'user',
+    'number',
+    'money',
+    'percentage',
+    'date',
+    'dateTime'
+]);
+const createReferencePlaceholder = '__GRIDFOX_REFERENCE_VALUE__';
+const hashText = (text) => {
+    let out = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        out = (out * 31 + text.charCodeAt(index)) >>> 0;
+    }
+    return out;
+};
+const createRunId = () => `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+const makeNumeric = (field, runId, variant) => {
+    const base = 100_000 + (hashText(`${field.name}:${runId}`) % 800_000);
+    return variant === 'create' ? base : base + 1;
+};
+const twoDigit = (value) => String(value).padStart(2, '0');
+const sampleValueForField = (field, variant, runId) => {
+    const tag = variant === 'create' ? 'c' : 'u';
+    const suffix = `${tag}-${runId}`;
+    switch (field.type) {
+        case 'text':
+        case 'textArea':
+        case 'richText':
+            return `real-${field.name.toLowerCase().replace(/\s+/g, '-')}-${suffix}`;
+        case 'email':
+            return `real-${suffix}@example.com`;
+        case 'user':
+            return `real-user-${suffix}`;
+        case 'number':
+        case 'money':
+        case 'percentage':
+            return makeNumeric(field, runId, variant);
+        case 'checkbox':
+            return variant === 'create';
+        case 'date': {
+            const day = 1 + (hashText(`${field.name}:${runId}:day`) % 28);
+            const month = variant === 'create' ? '01' : '02';
+            return `2026-${month}-${twoDigit(day)}`;
+        }
+        case 'dateTime': {
+            const day = 1 + (hashText(`${field.name}:${runId}:day`) % 28);
+            const hour = hashText(`${field.name}:${runId}:hour`) % 24;
+            const minute = hashText(`${field.name}:${runId}:minute`) % 60;
+            const month = variant === 'create' ? '01' : '02';
+            return `2026-${month}-${twoDigit(day)}T${twoDigit(hour)}:${twoDigit(minute)}:00.000Z`;
+        }
+        case 'list': {
+            const options = field.properties?.items?.map((item) => item.value) ?? [];
+            if (options.length >= 2) {
+                return variant === 'create' ? options[0] : options[1];
+            }
+            if (options.length === 1) {
+                return options[0];
+            }
+            return variant === 'create' ? 'Option A' : 'Option B';
+        }
+        case 'multiSelectList': {
+            const options = field.properties?.items?.map((item) => item.value) ?? [];
+            if (options.length >= 2) {
+                return variant === 'create' ? [options[0]] : [options[0], options[1]];
+            }
+            if (options.length === 1) {
+                return [options[0]];
+            }
+            return variant === 'create' ? ['Option A'] : ['Option B'];
+        }
+        default:
+            return undefined;
+    }
+};
+const findField = (table, fieldName) => table.fields.find((field) => field.name === fieldName);
+const supportsHeuristicField = (field) => scalarWritableTypes.has(field.type);
+const supportsUniqueValueGeneration = (field) => uniqueValueSafeTypes.has(field.type);
+export const buildHeuristicPlan = (tables, options = {}) => {
+    const runId = options.runId ?? createRunId();
+    const candidates = options.tableName === undefined ? sortByName(tables) : sortByName(tables.filter((table) => table.name === options.tableName));
+    if (options.tableName && candidates.length === 0) {
+        throw new Error(`Table "${options.tableName}" was not found in tables metadata`);
+    }
+    for (const table of candidates) {
+        const referenceField = findField(table, table.referenceFieldName);
+        if (!referenceField) {
+            continue;
+        }
+        if (!stringLikeReferenceTypes.has(referenceField.type)) {
+            continue;
+        }
+        const requiredWritableFields = table.fields.filter((field) => field.isRequired === true && isWritableFieldType(field.type));
+        if (requiredWritableFields.some((field) => !supportsHeuristicField(field))) {
+            continue;
+        }
+        if (requiredWritableFields.some((field) => field.isUnique === true && !supportsUniqueValueGeneration(field))) {
+            continue;
+        }
+        const writableFields = table.fields.filter((field) => isWritableFieldType(field.type) && supportsHeuristicField(field));
+        const updateCandidates = [
+            ...writableFields.filter((field) => field.isUnique !== true),
+            ...writableFields.filter((field) => field.isUnique === true && supportsUniqueValueGeneration(field))
+        ];
+        const updateCandidate = updateCandidates.find((field) => {
+            if (field.name === table.referenceFieldName) {
+                return false;
+            }
+            const createValue = sampleValueForField(field, 'create', runId);
+            const updateValue = sampleValueForField(field, 'update', runId);
+            return createValue !== undefined && updateValue !== undefined && createValue !== updateValue;
+        });
+        if (!updateCandidate) {
+            continue;
+        }
+        const createPayload = {
+            [table.referenceFieldName]: createReferencePlaceholder
+        };
+        for (const field of requiredWritableFields) {
+            if (field.name === table.referenceFieldName) {
+                continue;
+            }
+            const sample = sampleValueForField(field, 'create', runId);
+            if (sample === undefined) {
+                continue;
+            }
+            createPayload[field.name] = sample;
+        }
+        if (!(updateCandidate.name in createPayload)) {
+            const createSample = sampleValueForField(updateCandidate, 'create', runId);
+            if (createSample !== undefined) {
+                createPayload[updateCandidate.name] = createSample;
+            }
+        }
+        const updateSample = sampleValueForField(updateCandidate, 'update', runId);
+        if (updateSample === undefined) {
+            continue;
+        }
+        const updatePayload = {
+            [table.referenceFieldName]: createReferencePlaceholder,
+            [updateCandidate.name]: updateSample
+        };
+        const verifyAfterCreate = {
+            [table.referenceFieldName]: createReferencePlaceholder,
+            [updateCandidate.name]: createPayload[updateCandidate.name]
+        };
+        const verifyAfterUpdate = {
+            [table.referenceFieldName]: createReferencePlaceholder,
+            [updateCandidate.name]: updateSample
+        };
+        return {
+            tableName: table.name,
+            referenceFieldName: table.referenceFieldName,
+            referenceFieldType: referenceField.type,
+            createPayload,
+            updatePayload,
+            verifyAfterCreate,
+            verifyAfterUpdate,
+            rationale: 'Heuristic selected first CRUD-safe table'
+        };
+    }
+    if (options.tableName) {
+        throw new Error(`Table "${options.tableName}" is not CRUD-safe for heuristic real-project tests`);
+    }
+    throw new Error('Unable to find a CRUD-safe table for real-project tests');
+};

package/dist/validate/renderCrudTest.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutableCrudPlan } from './crudPlan.js';
+export declare const buildCrudTestSource: (plan: ExecutableCrudPlan) => string;