graphql-form 0.1.6 → 0.1.8

package/src/FormToCode/gql/formToGql.spec.ts

@@ -1,75 +0,0 @@
-import { formToGql } from './index';
-import {
-    extenedFields,
-    fields,
-    nodes,
-    replSpace,
-    singleNode,
-    fieldsNodeWithArgs,
-    fieldsNodeWithArgsWithInput,
-    nodeWithArgs,
-} from '../../__tests__';
-
-it('tranform form to Gql, typeNode, No args', () => {
-    // Arrange
-    const expectedValue = 'test';
-    // Act
-    const result = formToGql({ nodes: singleNode, fields });
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to Gql, typeNode, With args', () => {
-    // Arrange
-    const expectedValue = `testInput(
-        test: 5
-    )`;
-
-    // Act
-    const result = formToGql({ nodes, fields: extenedFields });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to Gql, typeNode, fieldsNodeWithArgs', () => {
-    // Arrange
-    const expectedValue = `testInput(
-        test: 5
-    )`;
-
-    // Act
-    const result = formToGql({ nodes, fields: fieldsNodeWithArgs });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to Gql, typeNode, fieldsNodeWithArgsWithInput', () => {
-    // Arrange
-    const expectedValue = 'testInput(testInput:[objectObject])';
-
-    // Act
-    const result = formToGql({ nodes, fields: fieldsNodeWithArgsWithInput });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to Gql, nodeWithArgs, fieldsNodeWithArgsWithInput', () => {
-    // Arrange
-    const expectedValue = 'testInput(testInput:[objectObject])';
-
-    // Act
-    const result = formToGql({ nodes: [nodeWithArgs], fields: fieldsNodeWithArgsWithInput });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-export {};

package/src/FormToCode/gql/index.ts

@@ -1,9 +0,0 @@
-import { fieldsToReductor, reduceQl } from './reducers';
-import { FormObject } from '@/models';
-import { ParserField } from 'graphql-js-tree';
-
-export const formToGql = ({ fields, nodes }: { nodes: ParserField[]; fields: Record<string, FormObject> }) => {
-    const reducedQl = fieldsToReductor(fields);
-    const q = reduceQl(reducedQl, nodes);
-    return q;
-};

package/src/FormToCode/gql/reducers.ts

@@ -1,50 +0,0 @@
-import { resolveQlValue } from './resolvers';
-import { Reductor, ReductorValue } from '@/FormToCode/models';
-import { FormObject } from '@/models';
-import { ParserField } from 'graphql-js-tree';
-
-export const fieldsToReductor = (toggledFields: Record<string, FormObject>): Reductor =>
-    Object.entries(toggledFields).reduce((a, [key, value]) => {
-        const pathElements = key
-            .replace('... on', '___on')
-            .split('.')
-            .map((e) => e.replace('___on', '... on'));
-        let start = a;
-        pathElements.forEach((el, index) => {
-            if (index === 0 && !!value.node.type.operations?.length) {
-                el = value.node.type.operations[0];
-            }
-            start[el] = start[el] || {};
-            start[el].reductor = start[el].reductor || {};
-            if (index === pathElements.length - 1) {
-                if (value.value && Object.keys(value.value).length > 0) {
-                    start[el].value = value.value;
-                }
-            }
-            start = start[el].reductor;
-        });
-        return a;
-    }, {} as Reductor);
-
-export const determineArgumentsQl = (v: ReductorValue, nodes: ParserField[], tabs = '') => {
-    if (v.value && Object.keys(v.value).length > 0) {
-        const resolvedValue = resolveQlValue(v.value, nodes, tabs);
-        if (resolvedValue) {
-            return `(${resolvedValue}\n${tabs})`;
-        }
-    }
-    return '';
-};
-
-export const reduceQl = (o: Reductor, nodes: ParserField[], tabs = ''): string => {
-    return Object.entries(o)
-        .map(([k, v]) => {
-            const kName = `${k}${determineArgumentsQl(v, nodes, tabs)}`;
-            const kObject =
-                Object.keys(v.reductor).length > 0
-                    ? `${tabs}${kName}{\n${reduceQl(v.reductor, nodes, tabs + '\t')}${tabs}}\n`
-                    : `${tabs}${kName}\n`;
-            return kObject;
-        })
-        .join('');
-};

package/src/FormToCode/gql/resolvers.ts

@@ -1,51 +0,0 @@
-import { FormObject, FormValue } from '@/models';
-import { ParserField, getTypeName, TypeDefinition, ScalarTypes } from 'graphql-js-tree';
-
-export const resolveSingularValue = (v: FormObject, nodes: ParserField[], tabs = ''): string => {
-    if (v.value === null) {
-        return 'null';
-    }
-    if (Array.isArray(v.value)) {
-        return `[${v.value
-            .map((subVal) => resolveSingularValue({ node: v.node, value: (subVal as FormObject).value }, nodes, tabs))
-            .join(', ')}]`;
-    }
-    const seekNode = nodes.find((n) => n.name === getTypeName(v.node.type.fieldType));
-    if (seekNode?.data.type === TypeDefinition.EnumTypeDefinition) {
-        return v.value as string;
-    }
-    if (seekNode?.data.type === TypeDefinition.ScalarTypeDefinition) {
-        return v.value as string;
-    }
-    if (seekNode) {
-        return `{${resolveQlValue(v.value, nodes, tabs + '\t')}\n${tabs}\t}`;
-    }
-    return getTypeName(v.node.type.fieldType) === ScalarTypes.String ? `"${v.value}"` : `${v.value}`;
-};
-
-export const resolveQlValue = (v: FormValue | undefined, nodes: ParserField[], tabs = '') => {
-    if (typeof v === 'undefined' || v === null) {
-        return '';
-    }
-    return Object.entries(v).reduce((a, [key, v]: [key: string, value: FormObject]) => {
-        if (typeof v.value === 'undefined' || v.value === '') {
-            return a;
-        }
-        if (Array.isArray(v.value) && v.value.length === 0) {
-            return a;
-        }
-        if (
-            typeof v.value === 'object' &&
-            v.value !== null &&
-            !Object.values(v.value).some(
-                (val) =>
-                    typeof val === 'object' && val !== null && 'value' in val && (!!val.value || val.value === false),
-            )
-        ) {
-            return a;
-        }
-        const resolvedValue = resolveSingularValue(v, nodes, tabs);
-        a = `${a}\n\t${tabs}${key}: ${resolvedValue}`;
-        return a;
-    }, '');
-};

package/src/FormToCode/index.ts

@@ -1,3 +0,0 @@
-export * from '@/FormToCode/gql';
-export * from '@/FormToCode/zeus';
-export * from '@/FormToCode/models';

package/src/FormToCode/models.ts

@@ -1,9 +0,0 @@
-import { FormValue } from '@/models';
-
-export type ReductorValue = {
-    reductor: Reductor;
-    value?: FormValue;
-};
-export type Reductor = {
-    [key: string]: ReductorValue;
-};

package/src/FormToCode/zeus/formToZeus.spec.ts

@@ -1,84 +0,0 @@
-import { formToZeus } from './index';
-import {
-    extenedFields,
-    nodes,
-    replSpace,
-    singleNode,
-    fields,
-    fieldsNodeWithArgs,
-    fieldsNodeWithArgsWithInput,
-} from '../../__tests__';
-
-it('tranform form to zeus, typeNode, No args', () => {
-    // Arrange
-    const expectedValue = 'api("undefined")({})';
-
-    // Act
-    const result = formToZeus({ nodes: singleNode, fields });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to zeus, typeNode, With args', () => {
-    // Arrange
-    const expectedValue = 'api("undefined")({})';
-
-    // Act
-    const result = formToZeus({ nodes: nodes, fields });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to zeus, inputNode, With args', () => {
-    // Arrange
-    const expectedValue = 'testInput:[{test:5},true]';
-
-    // Act
-    const result = formToZeus({ nodes: nodes, fields: extenedFields });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to zeus, singleTypeNode, No args', () => {
-    // Arrange
-    const expectedValue = 'testInput:[{test:5},true]';
-
-    // Act
-    const result = formToZeus({ nodes: singleNode, fields: extenedFields });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to zeus, singleTypeNode, fieldsNodeWithArgs', () => {
-    // Arrange
-    const expectedValue = 'testInput:[{test:5},true]';
-
-    // Act
-    const result = formToZeus({ nodes: singleNode, fields: fieldsNodeWithArgs });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-it('tranform form to zeus, singleTypeNode, fieldsNodeWithArgsWithInput', () => {
-    // Arrange
-    const expectedValue = 'testInput:[{testInput:[objectObject]},true]';
-
-    // Act
-    const result = formToZeus({ nodes: singleNode, fields: fieldsNodeWithArgsWithInput });
-
-    // Assert
-    const matchExact = replSpace(result);
-    matchExact(expectedValue);
-});
-
-export {};

package/src/FormToCode/zeus/index.ts

@@ -1,9 +0,0 @@
-import { zeusFieldsToReductor, zeusReduceQl } from './resolvers';
-import { FormObject } from '@/models';
-import { ParserField } from 'graphql-js-tree';
-
-export const formToZeus = ({ fields, nodes }: { nodes: ParserField[]; fields: Record<string, FormObject> }) => {
-    const reducedQl = zeusFieldsToReductor(fields);
-    const q = zeusReduceQl(reducedQl, nodes);
-    return q;
-};

package/src/FormToCode/zeus/resolvers.tsx

@@ -1,58 +0,0 @@
-import { resolveQlValue } from '../gql/resolvers';
-import { Reductor } from '../models';
-import { FormObject } from '@/models';
-import { ParserField } from 'graphql-js-tree';
-
-export const zeusFieldsToReductor = (toggledFields: Record<string, FormObject>): Reductor => {
-    const r = Object.entries(toggledFields).reduce((a, [key, value]) => {
-        const pathElements = key
-            .replace('... on', '___on')
-            .split('.')
-            .map((e) => e.replace('___on', '... on'));
-        let start = a;
-        pathElements.forEach((el, index) => {
-            if (index === 0 && !!value.node.type.operations?.length) {
-                el = value.node.type.operations[0];
-                return;
-            }
-            start[el] = start[el] || {};
-            start[el].reductor = start[el].reductor || {};
-            if (index === pathElements.length - 1) {
-                if (value.value && Object.keys(value.value).length > 0) {
-                    start[el].value = value.value;
-                }
-            }
-            start = start[el].reductor;
-        });
-        return a;
-    }, {} as Reductor);
-    return r;
-};
-
-export const zeusReduceQl = (o: Reductor, nodes: ParserField[], tabs = '', level = 0): string => {
-    const lUP = level + 1;
-    return Object.entries(o)
-        .map(([k, v]) => {
-            if (v.value && Object.keys(v.value).length > 0) {
-                return Object.keys(v.reductor).length > 0
-                    ? `${tabs}${k}:[{${resolveQlValue(v.value, nodes, tabs)}\n${tabs}}, {\n${zeusReduceQl(
-                          v.reductor,
-                          nodes,
-                          tabs + '\t',
-                          lUP,
-                      )}${tabs}}]\n`
-                    : `${tabs}${k}:[{${resolveQlValue(v.value, nodes, tabs)}\n${tabs}}, true]`;
-            }
-            if (level === 0) {
-                return `const result = await api("${
-                    nodes.find((n) => n.name === k)?.type.operations?.[0]
-                }")({\n${zeusReduceQl(v.reductor, nodes, tabs + '\t', lUP)}})`;
-            }
-            const kObject =
-                Object.keys(v.reductor).length > 0
-                    ? `${tabs}${k}:{\n${zeusReduceQl(v.reductor, nodes, tabs + '\t', lUP)}${tabs}}\n`
-                    : `${tabs}${k}: true\n`;
-            return kObject;
-        })
-        .join('');
-};

package/src/createWidget.tsx

@@ -1,8 +0,0 @@
-import { WidgetProps } from '@/models';
-
-export function createWidget<Props>(params: WidgetProps<Props>): WidgetProps<Props> & { props: Props } {
-    return {
-        ...params,
-        props: {} as Props,
-    };
-}

package/src/outsideUse.tsx

@@ -1,156 +0,0 @@
-import { Errs, FormFile, FormObject, FormValue, PassedFormProps } from '@/models';
-import {
-    getTypeName,
-    Options,
-    Parser,
-    ScalarTypes,
-    TypeDefinition,
-    TypeSystemDefinition,
-    ValueDefinition,
-} from 'graphql-js-tree';
-
-export const getWidgetFromProps = (props: PassedFormProps) => {
-    const w = props.widgets?.[props.currentPath];
-    const FoundBasicWidget = props.widgetComponents.find((wc) => wc.name === w?.widget);
-    if (!FoundBasicWidget) {
-        const widgetVariant = props.widgetVariants?.find((wv) => wv.name === w?.widget);
-        if (!widgetVariant) {
-            return;
-        }
-        const FoundVariantWidget = props.widgetComponents.find((wc) => wc.name === widgetVariant.widget);
-        if (!FoundVariantWidget) {
-            return;
-        }
-        return {
-            data: {
-                widget: widgetVariant.widget,
-                ...widgetVariant.data,
-            },
-            widget: FoundVariantWidget,
-        };
-    }
-    return {
-        data: w,
-        widget: FoundBasicWidget,
-    };
-};
-export const getErrorFromProps = (props: PassedFormProps) => {
-    return props.errors?.[props.currentPath];
-};
-
-export const graphqlFormUtils = (schema: string) => {
-    const nodes = Parser.parse(schema).nodes;
-
-    const validateValue = (f: FormValue, path: string, pushErrors: (path: string, value: Errs) => void) => {
-        if (
-            f === null ||
-            typeof f === 'string' ||
-            typeof f === 'boolean' ||
-            typeof f === 'number' ||
-            typeof f === 'undefined'
-        ) {
-            return;
-        }
-        if (
-            'node' in f &&
-            typeof f.node === 'object' &&
-            f.node !== null &&
-            'args' in f.node &&
-            'data' in f.node &&
-            typeof f.node.data === 'object' &&
-            !!f.node.data &&
-            'type' in f.node.data &&
-            'directives' in f.node
-        ) {
-            const { node, value } = f as FormObject;
-            if (node.data.type === ValueDefinition.InputValueDefinition) {
-                if (
-                    node.type.fieldType.type === Options.required &&
-                    getTypeName(node.type.fieldType) !== ScalarTypes.Boolean
-                ) {
-                    if (typeof value === 'undefined' || value === '') {
-                        pushErrors(path, Errs.REQUIRED);
-                    }
-                    if (Array.isArray(value)) {
-                        for (const v of value) {
-                            validateValue(v, path, pushErrors);
-                        }
-                    }
-                }
-            }
-        }
-        if ('value' in f && !!f.value) {
-            const { value } = f;
-            if (Array.isArray(value)) {
-                value.map((vv) => validateValue(vv, path, pushErrors));
-                return;
-            }
-            if (typeof value === 'object' && !!value) {
-                Object.entries(value).forEach(([k, v]) => validateValue(v as FormObject, `${path}.${k}`, pushErrors));
-                return;
-            }
-        }
-        return;
-    };
-
-    const validateForm = (v: FormFile, errors: Record<Errs, string>) => {
-        const errorDict: Record<string, string> = {};
-        if (!v.forms) return errorDict;
-        Object.entries(v.forms).forEach(([k, val]) => {
-            validateValue(val, k, (p, err) => {
-                errorDict[p] = errors[err];
-            });
-        });
-        return errorDict;
-    };
-
-    const eraseValue = (f: FormObject): FormObject => {
-        const { value, node } = f;
-
-        const seekNode = nodes.find((n) => n.name === getTypeName(node.type.fieldType));
-        if (
-            !seekNode ||
-            seekNode?.data.type === TypeDefinition.EnumTypeDefinition ||
-            seekNode?.data.type === TypeDefinition.ScalarTypeDefinition
-        ) {
-            return {
-                ...f,
-                value: undefined,
-            };
-        }
-        if ((seekNode || node.data.type === TypeSystemDefinition.FieldDefinition) && value) {
-            return {
-                ...f,
-                value: Object.fromEntries(Object.entries(value).map(([k, v]) => [k, eraseValue(v as FormObject)])),
-            };
-        }
-        return {
-            ...f,
-            value: undefined,
-        };
-    };
-
-    const eraseForm = (v: FormFile) => {
-        if (!v.forms) return v;
-        const forms = Object.entries(v.forms)
-            .map(([k, val]) => {
-                return [k, eraseValue(val)] as const;
-            })
-            .reduce(
-                (a, [k, val]) => ({
-                    ...a,
-                    [k]: val,
-                }),
-                {} as FormFile['forms'],
-            );
-        return {
-            ...v,
-            forms,
-        };
-    };
-    return {
-        eraseForm,
-        validateForm,
-        validateValue,
-    };
-};

package/src/renderer/fields.tsx

@@ -1,60 +0,0 @@
-import { PassedFormProps } from '@/models';
-import { getWidgetFromProps } from '@/outsideUse';
-import { getTypeName, Options, ScalarTypes, TypeDefinition, TypeSystemDefinition } from 'graphql-js-tree';
-import React from 'react';
-
-export const Fields: React.FC<PassedFormProps> = (props) => {
-    const {
-        nodes,
-        f,
-        components: { ArrayField, ObjectField },
-    } = props;
-    const seekNode = nodes.find((n) => n.name === getTypeName(f.type.fieldType));
-    const isInput = seekNode?.data.type === TypeDefinition.InputObjectTypeDefinition;
-    if (f.data.type === TypeSystemDefinition.FieldDefinition) {
-        return <ObjectField {...props} />;
-    }
-    if (f.type.fieldType.type === Options.array) {
-        return <ArrayField {...props} />;
-    }
-    if (isInput) {
-        return <ObjectField {...props} f={seekNode} />;
-    }
-    const w = getWidgetFromProps(props);
-    if (w) {
-        const {
-            data,
-            widget: { Component },
-        } = w;
-        return <Component {...props} widgetData={data} />;
-    }
-    return <ScalarField {...props} />;
-};
-const ScalarField: React.FC<PassedFormProps> = (props) => {
-    const {
-        f,
-        nodes,
-        children,
-        components: { BooleanField, NumberField, EnumField, UniversalField },
-    } = props;
-    const typeName = getTypeName(f.type.fieldType);
-    const seekNode = nodes.find((n) => n.name === getTypeName(f.type.fieldType));
-    if (
-        typeName === ScalarTypes.String ||
-        typeName === ScalarTypes.ID ||
-        seekNode?.data.type === TypeDefinition.ScalarTypeDefinition
-    ) {
-        return <UniversalField {...props} />;
-    }
-
-    if (typeName === ScalarTypes.Float || typeName === ScalarTypes.Int) {
-        return <NumberField {...props} />;
-    }
-    if (typeName === ScalarTypes.Boolean) {
-        return <BooleanField {...props} />;
-    }
-    if (seekNode?.data.type === TypeDefinition.EnumTypeDefinition) {
-        return <EnumField {...props} />;
-    }
-    return <>{children}</>;
-};

package/src/renderer/index.tsx

@@ -1,53 +0,0 @@
-import { InjectedValue } from '@/BuiltInFields/InjectedValue';
-import { PassedFormProps } from '@/models';
-import { Fields } from '@/renderer/fields';
-import { TypeSystemDefinition, Options, getTypeName, TypeDefinition } from 'graphql-js-tree';
-import React, { useState } from 'react';
-
-export const Renderer: React.FC<PassedFormProps> = (props) => {
-    const {
-        formObject,
-        f,
-        nodes,
-        presetValues,
-        components: { NullField, FormLabel, FormField },
-    } = props;
-    const { children, ...allProps } = props;
-    const seekNode = nodes.find((n) => n.name === getTypeName(f.type.fieldType));
-    const isInput = seekNode?.data.type === TypeDefinition.InputObjectTypeDefinition;
-    const canBeOpened = props.f.data.type === TypeSystemDefinition.FieldDefinition || isInput;
-    const [open, setOpen] = useState(props.f.data.type === TypeSystemDefinition.FieldDefinition || props.required);
-    if (f.type.fieldType.type === Options.required) {
-        return (
-            <Renderer
-                {...props}
-                f={{
-                    ...f,
-                    type: { ...f.type, fieldType: { ...f.type.fieldType.nest } },
-                }}
-                required={true}
-            />
-        );
-    }
-    const hasOverride = presetValues?.[props.currentPath];
-    if (hasOverride) {
-        return (
-            <InjectedValue
-                {...props}
-                widgetData={{
-                    value: hasOverride,
-                }}
-            />
-        );
-    }
-    return (
-        <FormField {...allProps}>
-            <FormLabel {...allProps} open={open} setOpen={setOpen} children={children} />
-            {formObject.value === null ? (
-                <NullField {...allProps} />
-            ) : (
-                <>{(!canBeOpened || open) && <Fields {...allProps} />}</>
-            )}
-        </FormField>
-    );
-};