@snowtop/ent 0.0.2 → 0.0.3-4.alpha

package/action/orchestrator.js

@@ -5,6 +5,7 @@ const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
 const action_1 = require("../action");
 const snake_case_1 = require("snake-case");
+const camel_case_1 = require("camel-case");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
@@ -58,6 +59,8 @@ class Orchestrator {
         this.changesets = [];
         this.dependencies = new Map();
         this.fieldsToResolve = [];
+        this.defaultFieldsByFieldName = {};
+        this.defaultFieldsByTSName = {};
         this.viewer = options.viewer;
     }
     addEdge(edge, op) {
@@ -143,6 +146,8 @@ class Orchestrator {
                     tableName: this.options.tableName,
                     fieldsToResolve: this.fieldsToResolve,
                     key: this.options.key,
+                    ent: this.options.loaderOptions.ent,
+                    placeholderID: this.options.builder.placeholderID,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
@@ -188,7 +193,7 @@ class Orchestrator {
         throw new Error("could not find an edge operation from the given parameters");
     }
     async buildEdgeOps(ops) {
-        const edgeDatas = await ent_1.loadEdgeDatas(...Array.from(this.edgeSet.values()));
+        const edgeDatas = await (0, ent_1.loadEdgeDatas)(...Array.from(this.edgeSet.values()));
         for (const [edgeType, m] of this.edges) {
             for (const [op, m2] of m) {
                 for (const [_, edge] of m2) {
@@ -222,53 +227,65 @@ class Orchestrator {
         }
         return new EntCannotDeleteEntError(privacyPolicy, action, this.options.builder.existingEnt);
     }
+    getEntForPrivacyPolicy(editedData) {
+        if (this.options.operation !== action_1.WriteOperation.Insert) {
+            return this.options.builder.existingEnt;
+        }
+        // we create an unsafe ent to be used for privacy policies
+        return new this.options.builder.ent(this.options.builder.viewer, editedData);
+    }
     async validate() {
+        // existing ent required for edit or delete operations
+        switch (this.options.operation) {
+            case action_1.WriteOperation.Delete:
+            case action_1.WriteOperation.Edit:
+                if (!this.options.builder.existingEnt) {
+                    throw new Error("existing ent required with operation");
+                }
+        }
         const action = this.options.action;
-        let privacyPolicy = action?.getPrivacyPolicy();
         const builder = this.options.builder;
-        let promises = [];
+        // future optimization: can get schemaFields to memoize based on different values
+        const schemaFields = (0, schema_1.getFields)(this.options.schema);
+        let editedData = this.getFieldsWithDefaultValues(builder, schemaFields, action);
+        // this runs in following phases:
+        // * set default fields and pass to builder so the value can be checked by triggers/observers/validators
+        // * privacy policy (use unsafe ent if we have it)
+        // * triggers
+        // * validators
+        let privacyPolicy = action?.getPrivacyPolicy();
         if (privacyPolicy) {
-            promises.push(privacy_1.applyPrivacyPolicyX(this.options.viewer, privacyPolicy, builder.existingEnt, this.throwError.bind(this)));
+            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicy(editedData), this.throwError.bind(this));
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
         let triggers = action?.triggers;
         if (triggers) {
-            let triggerPromises = [];
-            triggers.forEach((trigger) => {
-                let c = trigger.changeset(builder, action.getInput());
-                if (c) {
-                    triggerPromises.push(c);
-                }
-            });
-            // TODO right now trying to parallelize this with validateFields below
-            // may need to run triggers first to be deterministic
-            // TODO: see https://github.com/lolopinto/ent/pull/50
-            promises.push(this.triggers(triggerPromises));
+            await this.triggers(action, builder, triggers);
         }
-        promises.push(this.validateFields());
         let validators = action?.validators || [];
-        if (validators) {
-            promises.push(this.validators(validators, action, builder));
-        }
-        await Promise.all(promises);
-    }
-    async triggers(triggerPromises) {
-        // keep changesets to use later
-        let changesets = await Promise.all(triggerPromises.map(async (promise) => {
-            if (Array.isArray(promise)) {
-                return await Promise.all(promise);
+        await Promise.all([
+            this.formatAndValidateFields(schemaFields),
+            this.validators(validators, action, builder),
+        ]);
+    }
+    async triggers(action, builder, triggers) {
+        await Promise.all(triggers.map(async (trigger) => {
+            let ret = await trigger.changeset(builder, action.getInput());
+            if (Array.isArray(ret)) {
+                ret = await Promise.all(ret);
             }
-            return await promise;
-        }));
-        changesets.forEach((c) => {
-            if (Array.isArray(c)) {
-                this.changesets.push(...c);
+            if (Array.isArray(ret)) {
+                for (const v of ret) {
+                    if (typeof v === "object") {
+                        this.changesets.push(v);
+                    }
+                }
             }
-            else if (c) {
-                this.changesets.push(c);
+            else if (ret) {
+                this.changesets.push(ret);
             }
-        });
+        }));
     }
     async validators(validators, action, builder) {
         let promises = [];
@@ -283,88 +300,157 @@ class Orchestrator {
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
-    async validateFields() {
-        // existing ent required for edit or delete operations
-        switch (this.options.operation) {
-            case action_1.WriteOperation.Delete:
-            case action_1.WriteOperation.Edit:
-                if (!this.options.builder.existingEnt) {
-                    throw new Error("existing ent required with operation");
-                }
-        }
-        if (this.options.operation == action_1.WriteOperation.Delete) {
-            return;
-        }
+    getFieldsWithDefaultValues(builder, schemaFields, action) {
         const editedFields = this.options.editedFields();
-        // build up data to be saved...
         let data = {};
-        let logValues = {};
-        const schemaFields = schema_1.getFields(this.options.schema);
+        let defaultData = {};
+        let input = action?.getInput() || {};
+        let updateInput = false;
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
-            let dbKey = field.storageKey || snake_case_1.snakeCase(field.name);
+            let defaultValue = undefined;
+            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
             if (value === undefined) {
-                if (field.defaultValueOnCreate &&
-                    this.options.operation === action_1.WriteOperation.Insert) {
-                    value = field.defaultValueOnCreate();
+                if (this.options.operation === action_1.WriteOperation.Insert) {
+                    if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
+                        throw new Error(`cannot set both defaultToViewerOnCreate and defaultValueOnCreate`);
+                    }
+                    if (field.defaultToViewerOnCreate) {
+                        defaultValue = builder.viewer.viewerID;
+                    }
+                    if (field.defaultValueOnCreate) {
+                        defaultValue = field.defaultValueOnCreate(builder, input);
+                        if (defaultValue === undefined) {
+                            throw new Error(`defaultValueOnCreate() returned undefined for field ${field.name}`);
+                        }
+                    }
                 }
                 if (field.defaultValueOnEdit &&
                     this.options.operation === action_1.WriteOperation.Edit) {
-                    value = field.defaultValueOnEdit();
-                    // TODO special case this if this is the onlything changing and don't do the write.
+                    defaultValue = field.defaultValueOnEdit(builder, input);
                 }
             }
-            if (value === null) {
-                if (!field.nullable) {
-                    throw new Error(`field ${field.name} set to null for non-nullable field`);
-                }
+            if (value !== undefined) {
+                data[dbKey] = value;
             }
-            else if (value === undefined) {
-                if (!field.nullable &&
-                    // required field can be skipped if server default set
-                    // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
-                    // not setting server default as we're depending on the database handling that.
-                    // server default allowed
-                    field.serverDefault === undefined &&
-                    this.options.operation === action_1.WriteOperation.Insert) {
-                    throw new Error(`required field ${field.name} not set`);
-                }
+            if (defaultValue !== undefined) {
+                updateInput = true;
+                defaultData[dbKey] = defaultValue;
+                this.defaultFieldsByFieldName[fieldName] = defaultValue;
+                // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
+                this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
             }
-            else if (this.isBuilder(value)) {
-                let builder = value;
-                // keep track of dependencies to resolve
-                this.dependencies.set(builder.placeholderID, builder);
-                // keep track of fields to resolve
-                this.fieldsToResolve.push(dbKey);
+        }
+        // if there's data changing, add data
+        if (this.hasData(data)) {
+            data = {
+                ...data,
+                ...defaultData,
+            };
+            if (updateInput && this.options.updateInput) {
+                // this basically fixes #605. just needs to be exposed correctly
+                this.options.updateInput(this.defaultFieldsByTSName);
             }
-            else {
-                if (field.valid) {
-                    // TODO this could be async. handle this better
-                    let valid = await Promise.resolve(field.valid(value));
-                    if (!valid) {
-                        throw new Error(`invalid field ${field.name} with value ${value}`);
-                    }
+        }
+        return data;
+    }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
+    async transformFieldValue(field, dbKey, value) {
+        // now format and validate...
+        if (value === null) {
+            if (!field.nullable) {
+                throw new Error(`field ${field.name} set to null for non-nullable field`);
+            }
+        }
+        else if (value === undefined) {
+            if (!field.nullable &&
+                // required field can be skipped if server default set
+                // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
+                // not setting server default as we're depending on the database handling that.
+                // server default allowed
+                field.serverDefault === undefined &&
+                this.options.operation === action_1.WriteOperation.Insert) {
+                throw new Error(`required field ${field.name} not set`);
+            }
+        }
+        else if (this.isBuilder(value)) {
+            if (field.valid) {
+                const valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
                 }
-                if (field.format) {
-                    // TODO this could be async e.g. password. handle this better
-                    value = await Promise.resolve(field.format(value));
+            }
+            // keep track of dependencies to resolve
+            this.dependencies.set(value.placeholderID, value);
+            // keep track of fields to resolve
+            this.fieldsToResolve.push(dbKey);
+        }
+        else {
+            if (field.valid) {
+                // TODO this could be async. handle this better
+                const valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
                 }
             }
+            if (field.format) {
+                // TODO this could be async e.g. password. handle this better
+                value = await Promise.resolve(field.format(value));
+            }
+        }
+        return value;
+    }
+    async formatAndValidateFields(schemaFields) {
+        const op = this.options.operation;
+        if (op === action_1.WriteOperation.Delete) {
+            return;
+        }
+        const editedFields = this.options.editedFields();
+        // build up data to be saved...
+        let data = {};
+        let logValues = {};
+        for (const [fieldName, field] of schemaFields) {
+            let value = editedFields.get(fieldName);
+            if (value === undefined && op === action_1.WriteOperation.Insert) {
+                // null allowed
+                value = this.defaultFieldsByFieldName[fieldName];
+            }
+            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+            value = await this.transformFieldValue(field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
             }
         }
+        //  we ignored default values while editing.
+        // if we're editing and there's data, add default values
+        if (op === action_1.WriteOperation.Edit && this.hasData(data)) {
+            for (const fieldName in this.defaultFieldsByFieldName) {
+                const defaultValue = this.defaultFieldsByFieldName[fieldName];
+                let field = schemaFields.get(fieldName);
+                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                // no value, let's just default
+                if (data[dbKey] === undefined) {
+                    const value = await this.transformFieldValue(field, dbKey, defaultValue);
+                    data[dbKey] = value;
+                    logValues[dbKey] = field.logValue(value);
+                }
+            }
+        }
         this.validatedFields = data;
         this.logValues = logValues;
-        //    console.log(this.validatedFields);
     }
     async valid() {
         try {
             await this.validate();
         }
         catch (e) {
-            logger_1.log("error", e);
+            (0, logger_1.log)("error", e);
             return false;
         }
         return true;
@@ -377,7 +463,6 @@ class Orchestrator {
         await this.validX();
         let ops = [this.buildMainOp()];
         await this.buildEdgeOps(ops);
-        //    console.log("post build");
         return new EntChangeset(this.options.viewer, this.options.builder.placeholderID, this.options.loaderOptions.ent, ops, this.dependencies, this.changesets, this.options);
     }
     async viewerForEntLoad(data) {
@@ -385,11 +470,11 @@ class Orchestrator {
         if (!action || !action.viewerForEntLoad) {
             return this.options.viewer;
         }
-        return await action.viewerForEntLoad(data);
+        return action.viewerForEntLoad(data);
     }
     async returnedRow() {
-        if (this.mainOp && this.mainOp.returnedEntRow) {
-            return this.mainOp.returnedEntRow();
+        if (this.mainOp && this.mainOp.returnedRow) {
+            return this.mainOp.returnedRow();
         }
         return null;
     }
@@ -399,7 +484,7 @@ class Orchestrator {
             return null;
         }
         const viewer = await this.viewerForEntLoad(row);
-        return await ent_1.applyPrivacyPolicyForRow(viewer, this.options.loaderOptions, row);
+        return (0, ent_1.applyPrivacyPolicyForRow)(viewer, this.options.loaderOptions, row);
     }
     async editedEntX() {
         const row = await this.returnedRow();
@@ -407,7 +492,7 @@ class Orchestrator {
             throw new Error(`ent was not created`);
         }
         const viewer = await this.viewerForEntLoad(row);
-        const ent = await ent_1.applyPrivacyPolicyForRow(viewer, this.options.loaderOptions, row);
+        const ent = await (0, ent_1.applyPrivacyPolicyForRow)(viewer, this.options.loaderOptions, row);
         if (!ent) {
             if (this.options.operation == action_1.WriteOperation.Insert) {
                 throw new Error(`was able to create ent but not load it`);
@@ -431,13 +516,17 @@ class EntChangeset {
         this.options = options;
     }
     executor() {
-        // TODO: write comment here similar to go
-        // if we have dependencies but no changesets, we just need a simple
-        // executor and depend on something else in the stack to handle this correctly
-        if (this.changesets?.length) {
-            return new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.ent, this.operations, this.dependencies, this.changesets, this.options);
+        if (this._executor) {
+            return this._executor;
+        }
+        if (!this.changesets?.length) {
+            // if we have dependencies but no changesets, we just need a simple
+            // executor and depend on something else in the stack to handle this correctly
+            // ComplexExecutor which could be a parent of this should make sure the dependency
+            // is resolved beforehand
+            return (this._executor = new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.operations, this.options));
         }
-        return new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.ent, this.operations, this.options);
+        return (this._executor = new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.operations, this.dependencies || new Map(), this.changesets || [], this.options));
     }
 }
 exports.EntChangeset = EntChangeset;

package/action/privacy.js

@@ -11,9 +11,9 @@ class DenyIfBuilder {
     }
     async apply(_v, _ent) {
         if (this.id && isBuilder(this.id)) {
-            return base_1.Deny();
+            return (0, base_1.Deny)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.DenyIfBuilder = DenyIfBuilder;
@@ -23,9 +23,9 @@ class AllowIfBuilder {
     }
     async apply(_v, _ent) {
         if (this.id && isBuilder(this.id)) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.AllowIfBuilder = AllowIfBuilder;

package/auth/auth.js

@@ -17,11 +17,11 @@ async function getLoggedInViewer(context) {
     for (const [name, authHandler] of handlers) {
         let v = await authHandler.authViewer(context);
         if (v !== null) {
-            logger_1.log("info", `auth handler \`${name}\` authenticated user \`${v.viewerID}\``);
+            (0, logger_1.log)("info", `auth handler \`${name}\` authenticated user \`${v.viewerID}\``);
             return v;
         }
     }
-    logger_1.log("info", "no auth handler returned viewer. default to logged out viewer");
+    (0, logger_1.log)("info", "no auth handler returned viewer. default to logged out viewer");
     return null;
 }
 exports.getLoggedInViewer = getLoggedInViewer;

package/core/base.js

@@ -9,22 +9,25 @@ var privacyResult;
     privacyResult[privacyResult["Deny"] = 401] = "Deny";
     privacyResult[privacyResult["Skip"] = 307] = "Skip";
 })(privacyResult || (privacyResult = {}));
+const allow = {
+    result: privacyResult.Allow,
+};
 function Allow() {
-    return {
-        result: privacyResult.Allow,
-    };
+    return allow;
 }
 exports.Allow = Allow;
+const skip = {
+    result: privacyResult.Skip,
+};
 function Skip() {
-    return {
-        result: privacyResult.Skip,
-    };
+    return skip;
 }
 exports.Skip = Skip;
+const deny = {
+    result: privacyResult.Deny,
+};
 function Deny() {
-    return {
-        result: privacyResult.Deny,
-    };
+    return deny;
 }
 exports.Deny = Deny;
 function DenyWithReason(e) {

package/core/clause.d.ts

@@ -28,6 +28,7 @@ declare class compositeClause implements Clause {
     instanceKey(): string;
 }
 export declare function Eq(col: string, value: any): simpleClause;
+export declare function NotEq(col: string, value: any): simpleClause;
 export declare function Greater(col: string, value: any): simpleClause;
 export declare function Less(col: string, value: any): simpleClause;
 export declare function GreaterEq(col: string, value: any): simpleClause;

package/core/clause.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.In = exports.Or = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.Eq = void 0;
+exports.sensitiveValue = exports.In = exports.Or = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (typeof val === "object" && val.logValue !== undefined);
@@ -149,6 +149,10 @@ function Eq(col, value) {
     return new simpleClause(col, value, "=");
 }
 exports.Eq = Eq;
+function NotEq(col, value) {
+    return new simpleClause(col, value, "!=");
+}
+exports.NotEq = NotEq;
 function Greater(col, value) {
     return new simpleClause(col, value, ">");
 }
@@ -173,7 +177,7 @@ function Or(...args) {
     return new compositeClause(args, " OR ");
 }
 exports.Or = Or;
-// todo?
+// TODO this breaks if values.length ===1 and array. todo fix
 function In(col, ...values) {
     return new inClause(col, values);
 }

package/core/config.d.ts

@@ -6,6 +6,26 @@ export interface Config {
     dbFile?: string;
     db?: Database | DBDict;
     log?: logType | logType[];
+    codegen?: CodegenConfig;
+}
+interface CodegenConfig {
+    defaultEntPolicy?: PrivacyConfig;
+    defaultActionPolicy?: PrivacyConfig;
+    prettier?: PrettierConfig;
+    relativeImports?: boolean;
+    disableGraphQLRoot?: boolean;
+    generatedHeader?: string;
+    disableBase64Encoding?: boolean;
+    generateRootResolvers?: boolean;
+}
+interface PrettierConfig {
+    custom?: boolean;
+    glob?: string;
+}
+interface PrivacyConfig {
+    path: string;
+    policyName: string;
+    class?: boolean;
 }
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};

package/core/config.js

@@ -30,7 +30,7 @@ const path = __importStar(require("path"));
 const logger_1 = require("./logger");
 function setConfig(cfg) {
     if (cfg.log) {
-        logger_1.setLogLevels(cfg.log);
+        (0, logger_1.setLogLevels)(cfg.log);
     }
     if (cfg.dbConnectionString || cfg.dbFile || cfg.db) {
         db_1.default.initDB({
@@ -68,7 +68,7 @@ function loadConfig(file) {
         }
     }
     try {
-        let yaml = js_yaml_1.load(data);
+        let yaml = (0, js_yaml_1.load)(data);
         if (typeof yaml !== "object") {
             throw new Error(`invalid yaml passed`);
         }

package/core/context.js

@@ -14,7 +14,7 @@ class ContextCache {
         if (l) {
             return l;
         }
-        logger_1.log("debug", `new context-aware loader created for ${name}`);
+        (0, logger_1.log)("debug", `new context-aware loader created for ${name}`);
         l = create();
         this.loaders.set(name, l);
         return l;
@@ -39,7 +39,7 @@ class ContextCache {
         const key = this.getkey(options);
         let rows = m.get(key);
         if (rows) {
-            logger_1.log("query", {
+            (0, logger_1.log)("query", {
                 "cache-hit": key,
                 "tableName": options.tableName,
             });
@@ -54,7 +54,7 @@ class ContextCache {
         const key = this.getkey(options);
         let row = m.get(key);
         if (row) {
-            logger_1.log("query", {
+            (0, logger_1.log)("query", {
                 "cache-hit": key,
                 "tableName": options.tableName,
             });

package/core/convert.d.ts

@@ -8,3 +8,7 @@ export declare function convertDateList(val: any): Date[];
 export declare function convertNullableDateList(val: any): Date[] | null;
 export declare function convertBoolList(val: any): boolean[];
 export declare function convertNullableBoolList(val: any): boolean[] | null;
+export declare function convertJSON(val: any): any;
+export declare function convertNullableJSON(val: any): any | null;
+export declare function convertJSONList(val: any): boolean[];
+export declare function convertNullableJSONList(val: any): any[] | null;

package/core/convert.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertNullableBoolList = exports.convertBoolList = exports.convertNullableDateList = exports.convertDateList = exports.convertNullableList = exports.convertList = exports.convertNullableBool = exports.convertBool = exports.convertNullableDate = exports.convertDate = void 0;
+exports.convertNullableJSONList = exports.convertJSONList = exports.convertNullableJSON = exports.convertJSON = exports.convertNullableBoolList = exports.convertBoolList = exports.convertNullableDateList = exports.convertDateList = exports.convertNullableList = exports.convertList = exports.convertNullableBool = exports.convertBool = exports.convertNullableDate = exports.convertDate = void 0;
 const luxon_1 = require("luxon");
 // these are needed to deal with SQLite having different types stored in the db vs the representation
 // gotten back from the db/needed in ent land
@@ -59,7 +59,8 @@ function convertList(val, conv) {
 }
 exports.convertList = convertList;
 function convertNullableList(val, conv) {
-    if (val === null) {
+    // undefined can happen with unsafe ents
+    if (val === null || val === undefined) {
         return null;
     }
     return convertList(val, conv);
@@ -81,3 +82,25 @@ function convertNullableBoolList(val) {
     return convertNullableList(val, convertBool);
 }
 exports.convertNullableBoolList = convertNullableBoolList;
+function convertJSON(val) {
+    if (typeof val === "string") {
+        return JSON.parse(val);
+    }
+    return val;
+}
+exports.convertJSON = convertJSON;
+function convertNullableJSON(val) {
+    if (val === null) {
+        return val;
+    }
+    return convertJSON(val);
+}
+exports.convertNullableJSON = convertNullableJSON;
+function convertJSONList(val) {
+    return convertList(val, convertJSON);
+}
+exports.convertJSONList = convertJSONList;
+function convertNullableJSONList(val) {
+    return convertNullableList(val, convertJSON);
+}
+exports.convertNullableJSONList = convertNullableJSONList;