@saltcorn/data 0.6.2-beta.4 → 0.6.3-beta.1

package/dist/models/field.js

@@ -5,18 +5,22 @@
  * @module models/field
  * @subcategory models
  */
-const db = require("../db");
-const { contract, is } = require("contractis");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const db_1 = __importDefault(require("../db"));
 const { recalculate_for_stored, jsexprToWhere } = require("./expression");
-const { sqlsanitize } = require("@saltcorn/db-common/internal");
+const internal_1 = require("@saltcorn/db-common/internal");
 const { InvalidAdminAction } = require("../utils");
-const { mkWhere } = require("../db");
+const common_types_1 = require("@saltcorn/types/common_types");
 const readKey = (v, field) => {
     if (v === "")
         return null;
     if (typeof v === "string" && v.startsWith("Preset:"))
         return v;
     const { getState } = require("../db/state");
+    if (!field.reftype)
+        throw new Error("Unable to find the type, 'reftype' is undefined.");
     const type = getState().types[field.reftype];
     const parsed = type.read(v);
     return parsed || (v ? { error: "Unable to read key" } : null);
@@ -31,10 +35,13 @@ class Field {
      * @param o
      */
     constructor(o) {
+        this.refname = "";
+        if (!o.name && !o.label)
+            throw new Error(`Field initialised with no name and no label`);
+        this.label = (o.label || o.name);
+        this.name = (o.name || Field.labelToName(this.label));
         if (!o.type && !o.input_type)
             throw new Error(`Field ${o.name} initialised with no type`);
-        this.label = o.label || o.name;
-        this.name = o.name || Field.labelToName(o.label);
         this.fieldview = o.fieldview;
         this.validator = o.validator || (() => true);
         this.showIf = o.showIf;
@@ -48,7 +55,7 @@ class Field {
         const { getState } = require("../db/state");
         this.type = typeof o.type === "string" ? getState().types[o.type] : o.type;
         if (!this.type)
-            this.typename = o.type;
+            this.typename = typeof o.type === "string" ? o.type : o.type?.name;
         this.options = o.options;
         this.required = o.required ? true : false;
         this.is_unique = o.is_unique ? true : false;
@@ -74,10 +81,9 @@ class Field {
             this.refname = "id";
         }
         else {
-            this.reftable_name =
-                o.reftable_name ||
-                    (o.reftable && o.reftable.name) ||
-                    o.type.replace("Key to ", "");
+            this.reftable_name = o.reftable_name || (o.reftable && o.reftable.name);
+            if (!this.reftable_name && o.type && typeof o.type === "string")
+                this.reftable_name = o.type.replace("Key to ", "");
             this.reftable = o.reftable;
             this.type = "Key";
             this.input_type =
@@ -96,7 +102,6 @@ class Field {
             if (o.table.id && !o.table_id)
                 this.table_id = o.table.id;
         }
-        contract.class(this);
     }
     /**
      * To Json
@@ -114,7 +119,7 @@ class Field {
             expression: this.expression,
             sublabel: this.sublabel,
             fieldview: this.fieldview,
-            type: typeof this.type === "string" ? this.type : this.type.name,
+            type: typeof this.type === "string" ? this.type : this.type?.name,
             reftable_name: this.reftable_name,
             attributes: this.attributes,
             required: this.required,
@@ -132,7 +137,7 @@ class Field {
     // todo from internalization point of view better to separate label, name. sqlname
     // because label can contain characters that cannot be used in PG for sql names
     static labelToName(label) {
-        return sqlsanitize(label.toLowerCase().replace(" ", "_"));
+        return (0, internal_1.sqlsanitize)(label.toLowerCase().replace(" ", "_"));
     }
     /**
      * ???
@@ -150,7 +155,7 @@ class Field {
      * @param {object} where
      * @returns {Promise<void>}
      */
-    async fill_fkey_options(force_allow_none = false, where0, extraCtx) {
+    async fill_fkey_options(force_allow_none = false, where0, extraCtx = {}) {
         const where = where0 ||
             (this.attributes.where
                 ? jsexprToWhere(this.attributes.where, extraCtx)
@@ -159,7 +164,7 @@ class Field {
         if (this.is_fkey &&
             (this.type !== "File" ||
                 typeof this.attributes.select_file_where !== "undefined")) {
-            const rows = await db.select(this.reftable_name, this.type === "File" ? this.attributes.select_file_where : where);
+            const rows = await db_1.default.select(this.reftable_name, this.type === "File" ? this.attributes.select_file_where : where);
             const summary_field = this.attributes.summary_field ||
                 (this.type === "File" ? "filename" : "id");
             const dbOpts = rows.map((r) => ({
@@ -179,7 +184,8 @@ class Field {
      */
     async distinct_values(req, where) {
         const __ = req && req.__ ? req.__ : (s) => s;
-        if (this.type.name === "String" &&
+        if ((0, common_types_1.instanceOfType)(this.type) &&
+            this.type.name === "String" &&
             this.attributes &&
             this.attributes.options) {
             return [
@@ -193,7 +199,7 @@ class Field {
             await this.fill_fkey_options(false, where);
             return this.options || [];
         }
-        if (this.type.name === "Bool") {
+        if ((0, common_types_1.instanceOfType)(this.type) && this.type.name === "Bool") {
             return [
                 { label: "", value: "" },
                 { label: __("True"), value: "on", jsvalue: true },
@@ -204,11 +210,11 @@ class Field {
         let whereS = "";
         let values = [];
         if (where) {
-            const whereValues = mkWhere(where);
+            const whereValues = db_1.default.mkWhere(where);
             whereS = whereValues.where;
             values = whereValues.values;
         }
-        const { rows } = await db.query(`select distinct "${db.sqlsanitize(this.name)}" from ${this.table.sql_name} ${whereS} order by "${db.sqlsanitize(this.name)}"`, values);
+        const { rows } = await db_1.default.query(`select distinct "${db_1.default.sqlsanitize(this.name)}" from ${this.table?.sql_name} ${whereS} order by "${db_1.default.sqlsanitize(this.name)}"`, values);
         const dbOpts = rows.map((r) => ({
             label: `${r[this.name]}`,
             value: r[this.name],
@@ -220,13 +226,17 @@ class Field {
      */
     get sql_type() {
         if (this.is_fkey) {
-            const schema = db.getTenantSchemaPrefix();
+            if (!this.reftype || !this.reftable_name) {
+                throw new Error("'reftype' and 'reftable_name' must be set if 'is_fkey' is true.");
+            }
+            const schema = db_1.default.getTenantSchemaPrefix();
             const { getState } = require("../db/state");
-            return `${getState().types[this.reftype].sql_name} references ${schema}"${sqlsanitize(this.reftable_name)}" ("${this.refname}")`;
+            return `${getState().types[this.reftype].sql_name} references ${schema}"${(0, internal_1.sqlsanitize)(this.reftable_name)}" ("${this.refname}")`;
         }
-        else {
+        else if (this.type && (0, common_types_1.instanceOfType)(this.type) && this.type.sql_name) {
             return this.type.sql_name;
         }
+        throw new Error("Unable to get the sql_type");
     }
     /**
      * @type {string}
@@ -237,31 +247,35 @@ class Field {
         if (this.is_fkey)
             return `Key to ${this.reftable_name}`;
         else
-            return this.type ? this.type.name : "?";
+            return this.type && (0, common_types_1.instanceOfType)(this.type) ? this.type.name : "?";
     }
     /**
      * @type {string}
      */
     get sql_bare_type() {
         if (this.is_fkey) {
+            if (!this.reftype || !this.reftable_name) {
+                throw new Error("'reftype' and 'reftable_name' must be set if 'is_fkey' is true.");
+            }
             const { getState } = require("../db/state");
             return getState().types[this.reftype].sql_name;
         }
-        else {
+        else if (this.type && (0, common_types_1.instanceOfType)(this.type) && this.type.sql_name) {
             return this.type.sql_name;
         }
+        throw new Error("Unable to get the sql_type");
     }
     /**
      * @returns {Promise<any>}
      */
     async generate() {
         if (this.is_fkey) {
-            const rows = await db.select(this.reftable_name, {}, { limit: 1, orderBy: "RANDOM()" });
+            const rows = await db_1.default.select(this.reftable_name, {}, { limit: 1, orderBy: "RANDOM()" });
             if (rows.length === 1)
                 return rows[0].id;
         }
         else {
-            if (this.type && this.type.contract)
+            if ((0, common_types_1.instanceOfType)(this.type) && this.type.contract)
                 return this.type.contract(this.attributes).generate();
         }
     }
@@ -271,19 +285,25 @@ class Field {
      */
     validate(whole_rec) {
         const type = this.is_fkey ? { name: "Key" } : this.type;
-        const readval = this.is_fkey
-            ? readKey(whole_rec[this.form_name], this)
-            : !type || !type.read
-                ? whole_rec[this.form_name]
-                : type.readFromFormRecord
-                    ? type.readFromFormRecord(whole_rec, this.form_name)
-                    : type.read(whole_rec[this.form_name], this.attributes);
+        let readval = null;
+        if (this.is_fkey) {
+            readval = readKey(whole_rec[this.form_name], this);
+        }
+        else {
+            let typeObj = this.type;
+            readval =
+                !type || !typeObj.read
+                    ? whole_rec[this.form_name]
+                    : typeObj.readFromFormRecord
+                        ? typeObj.readFromFormRecord(whole_rec, this.form_name)
+                        : typeObj.read(whole_rec[this.form_name], this.attributes);
+        }
         if (typeof readval === "undefined" || readval === null)
             if (this.required && this.type !== "File")
-                return { error: "Unable to read " + type.name };
+                return { error: "Unable to read " + type?.name };
             else
                 return { success: null };
-        const tyvalres = type && type.validate
+        const tyvalres = (0, common_types_1.instanceOfType)(type) && type.validate
             ? type.validate(this.attributes || {})(readval)
             : readval;
         if (tyvalres.error)
@@ -303,7 +323,7 @@ class Field {
      * @returns {Field[]}
      */
     static async find(where, selectopts = { orderBy: "name", nocase: true }) {
-        const db_flds = await db.select("_sc_fields", where, selectopts);
+        const db_flds = await db_1.default.select("_sc_fields", where, selectopts);
         return db_flds.map((dbf) => new Field(dbf));
     }
     /**
@@ -311,7 +331,7 @@ class Field {
      * @returns {Promise<Field>}
      */
     static async findOne(where) {
-        const db_fld = await db.selectOne("_sc_fields", where);
+        const db_fld = await db_1.default.selectOne("_sc_fields", where);
         return new Field(db_fld);
     }
     /**
@@ -319,14 +339,14 @@ class Field {
      */
     async add_unique_constraint() {
         await this.fill_table();
-        await db.add_unique_constraint(this.table.name, [this.name]);
+        await db_1.default.add_unique_constraint(this.table?.name, [this.name]);
     }
     /**
      * @returns {Promise<void>}
      */
     async remove_unique_constraint() {
         await this.fill_table();
-        await db.drop_unique_constraint(this.table.name, [this.name]);
+        await db_1.default.drop_unique_constraint(this.table?.name, [this.name]);
     }
     /**
      *
@@ -334,9 +354,12 @@ class Field {
      * @returns {Promise<void>}
      */
     async toggle_not_null(not_null) {
-        const schema = db.getTenantSchemaPrefix();
+        if (!this.table) {
+            throw new Error("To toogle a not null constraint, 'table' must be set.");
+        }
+        const schema = db_1.default.getTenantSchemaPrefix();
         await this.fill_table();
-        await db.query(`alter table ${schema}"${sqlsanitize(this.table.name)}" alter column "${sqlsanitize(this.name)}" ${not_null ? "set" : "drop"} not null;`);
+        await db_1.default.query(`alter table ${schema}"${(0, internal_1.sqlsanitize)(this.table.name)}" alter column "${(0, internal_1.sqlsanitize)(this.name)}" ${not_null ? "set" : "drop"} not null;`);
         await require("../db/state").getState().refresh_tables();
     }
     /**
@@ -344,22 +367,27 @@ class Field {
      * @returns {Promise<void>}
      */
     async alter_sql_type(new_field) {
+        if (!this.table) {
+            throw new Error(`To add the field '${new_field.name}', 'table' must be set.`);
+        }
         let new_sql_type = new_field.sql_type;
         let def = "";
-        let using = `USING ("${sqlsanitize(this.name)}"::${new_sql_type})`;
-        const schema = db.getTenantSchemaPrefix();
+        let using = `USING ("${(0, internal_1.sqlsanitize)(this.name)}"::${new_sql_type})`;
+        const schema = db_1.default.getTenantSchemaPrefix();
         await this.fill_table();
         if (new_field.primary_key) {
-            await db.query(`ALTER TABLE ${schema}"${sqlsanitize(this.table.name)}" drop column "${sqlsanitize(this.name)}";`);
-            if (new_field.type.primaryKey.sql_type)
-                new_sql_type = new_field.type.primaryKey.sql_type;
-            if (new_field.type.primaryKey.default_sql) {
-                def = `default ${new_field.type.primaryKey.default_sql}`;
+            await db_1.default.query(`ALTER TABLE ${schema}"${(0, internal_1.sqlsanitize)(this.table.name)}" drop column "${(0, internal_1.sqlsanitize)(this.name)}";`);
+            if ((0, common_types_1.instanceOfType)(new_field.type)) {
+                if (new_field.type.primaryKey?.sql_type)
+                    new_sql_type = new_field.type.primaryKey.sql_type;
+                if (new_field.type.primaryKey?.default_sql) {
+                    def = `default ${new_field.type.primaryKey.default_sql}`;
+                }
             }
-            await db.query(`ALTER TABLE ${schema}"${sqlsanitize(this.table.name)}" add column "${sqlsanitize(this.name)}" ${new_sql_type} primary key ${def};`);
+            await db_1.default.query(`ALTER TABLE ${schema}"${(0, internal_1.sqlsanitize)(this.table.name)}" add column "${(0, internal_1.sqlsanitize)(this.name)}" ${new_sql_type} primary key ${def};`);
         }
         else
-            await db.query(`alter table ${schema}"${sqlsanitize(this.table.name)}" alter column "${sqlsanitize(this.name)}" TYPE ${new_sql_type} ${using} ${def};`);
+            await db_1.default.query(`alter table ${schema}"${(0, internal_1.sqlsanitize)(this.table.name)}" alter column "${(0, internal_1.sqlsanitize)(this.name)}" TYPE ${new_sql_type} ${using} ${def};`);
         await require("../db/state").getState().refresh_tables();
     }
     /**
@@ -376,25 +404,30 @@ class Field {
      * @returns {Promise<void>}
      */
     async update(v) {
+        const f = new Field({ ...this, ...v });
+        const rename = f.name !== this.name;
+        if (rename && !this.table?.name) {
+            throw new Error("");
+        }
         if (typeof v.is_unique !== "undefined" &&
             !!v.is_unique !== !!this.is_unique) {
             if (v.is_unique && !this.is_unique)
                 await this.add_unique_constraint();
             if (!v.is_unique && this.is_unique)
                 await this.remove_unique_constraint();
-            await db.update("_sc_fields", { is_unique: v.is_unique }, this.id);
+            await db_1.default.update("_sc_fields", { is_unique: v.is_unique }, this.id);
         }
         if (typeof v.required !== "undefined" && !!v.required !== !!this.required)
             await this.toggle_not_null(!!v.required);
-        const f = new Field({ ...this, ...v });
         if (f.sql_type !== this.sql_type) {
             await this.alter_sql_type(f);
         }
-        if (f.name !== this.name) {
-            const schema = db.getTenantSchemaPrefix();
-            await db.query(`alter table ${schema}"${sqlsanitize(this.table.name)}" rename column "${sqlsanitize(this.name)}" TO ${f.name};`);
+        if (rename) {
+            const schema = db_1.default.getTenantSchemaPrefix();
+            await db_1.default.query(`alter table ${schema}"${(0, internal_1.sqlsanitize)(this.table.name // ensured above
+            )}" rename column "${(0, internal_1.sqlsanitize)(this.name)}" TO ${f.name};`);
         }
-        await db.update("_sc_fields", v, this.id);
+        await db_1.default.update("_sc_fields", v, this.id);
         Object.entries(v).forEach(([k, v]) => {
             this[k] = v;
         });
@@ -404,17 +437,18 @@ class Field {
      * @type {string}
      */
     get listKey() {
-        return this.type.listAs
-            ? (r) => this.type.listAs(r[this.name])
-            : this.type.showAs
-                ? (r) => this.type.showAs(r[this.name])
-                : this.name;
+        if ((0, common_types_1.instanceOfType)(this.type))
+            if (this.type.listAs)
+                return (r) => this.type.listAs(r[this.name]);
+            else if (this.type.showAs)
+                return (r) => this.type.showAs(r[this.name]);
+        return this.name;
     }
     /**
      * @type {object}
      */
     get presets() {
-        if (this.type && this.type.presets)
+        if ((0, common_types_1.instanceOfType)(this.type) && this.type.presets)
             return this.type.presets;
         if (this.type === "Key" && this.reftable_name === "users")
             return { LoggedIn: ({ user }) => user && user.id };
@@ -432,18 +466,18 @@ class Field {
         if (table.ownership_field_id === this.id) {
             throw new InvalidAdminAction(`Cannot delete field ${this.name} as it sets ownership for table ${table.name}`);
         }
-        const schema = db.getTenantSchemaPrefix();
-        const client = db.isSQLite ? db : await db.getClient();
+        const schema = db_1.default.getTenantSchemaPrefix();
+        const client = db_1.default.isSQLite ? db_1.default : await db_1.default.getClient();
         await client.query("BEGIN");
-        await db.deleteWhere("_sc_fields", { id: this.id }, { client });
-        if (!db.isSQLite && (!this.calculated || this.stored)) {
-            await client.query(`alter table ${schema}"${sqlsanitize(table.name)}" drop column "${sqlsanitize(this.name)}"`);
+        await db_1.default.deleteWhere("_sc_fields", { id: this.id }, { client });
+        if (!db_1.default.isSQLite && (!this.calculated || this.stored)) {
+            await client.query(`alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}" drop column "${(0, internal_1.sqlsanitize)(this.name)}"`);
             if (table.versioned) {
-                await client.query(`alter table ${schema}"${sqlsanitize(table.name)}__history" drop column "${sqlsanitize(this.name)}"`);
+                await client.query(`alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}__history" drop column "${(0, internal_1.sqlsanitize)(this.name)}"`);
             }
         }
         await client.query("COMMIT");
-        if (!db.isSQLite)
+        if (!db_1.default.isSQLite)
             await client.release(true);
         await require("../db/state").getState().refresh_tables();
     }
@@ -452,10 +486,13 @@ class Field {
      * @returns {Promise<void>}
      */
     async enable_fkey_constraint(table) {
-        if (this.is_fkey && !db.isSQLite) {
-            const schema = db.getTenantSchemaPrefix();
-            const q = `alter table ${schema}"${sqlsanitize(table.name)}" ADD CONSTRAINT "fkey_${sqlsanitize(table.name)}_${sqlsanitize(this.name)}" FOREIGN KEY ("${sqlsanitize(this.name)}") references ${schema}"${sqlsanitize(this.reftable_name)}" (id)`;
-            await db.query(q);
+        if (this.is_fkey && !db_1.default.isSQLite) {
+            if (!this.reftable_name) {
+                throw new Error("To enable a foreign key constraint, the 'reftable_name' must be set.");
+            }
+            const schema = db_1.default.getTenantSchemaPrefix();
+            const q = `alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}" ADD CONSTRAINT "fkey_${(0, internal_1.sqlsanitize)(table.name)}_${(0, internal_1.sqlsanitize)(this.name)}" FOREIGN KEY ("${(0, internal_1.sqlsanitize)(this.name)}") references ${schema}"${(0, internal_1.sqlsanitize)(this.reftable_name)}" (id)`;
+            await db_1.default.query(q);
         }
     }
     /**
@@ -465,9 +502,9 @@ class Field {
      */
     static async create(fld, bare = false) {
         const f = new Field(fld);
-        const schema = db.getTenantSchemaPrefix();
+        const schema = db_1.default.getTenantSchemaPrefix();
         const Table = require("./table");
-        const is_sqlite = db.isSQLite;
+        const is_sqlite = db_1.default.isSQLite;
         //const tables = await Table.find();
         //console.log({ tables, fld });
         if (f.is_fkey) {
@@ -484,34 +521,34 @@ class Field {
         const table = await Table.findOne({ id: f.table_id });
         if (!f.calculated || f.stored) {
             if (typeof f.attributes.default === "undefined") {
-                const q = `alter table ${schema}"${sqlsanitize(table.name)}" add column "${sqlsanitize(f.name)}" ${sql_type} ${f.required ? `not null ${is_sqlite ? 'default ""' : ""}` : ""}`;
-                await db.query(q);
+                const q = `alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}" add column "${(0, internal_1.sqlsanitize)(f.name)}" ${sql_type} ${f.required ? `not null ${is_sqlite ? 'default ""' : ""}` : ""}`;
+                await db_1.default.query(q);
             }
             else if (is_sqlite) {
                 //warning: not safe but sqlite so we don't care
-                const q = `alter table ${schema}"${sqlsanitize(table.name)}" add column "${sqlsanitize(f.name)}" ${sql_type} ${f.required
+                const q = `alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}" add column "${(0, internal_1.sqlsanitize)(f.name)}" ${sql_type} ${f.required
                     ? `not null default ${JSON.stringify(f.attributes.default)}`
                     : ""}`;
-                await db.query(q);
+                await db_1.default.query(q);
             }
             else {
-                const q = `DROP FUNCTION IF EXISTS add_field_${sqlsanitize(f.name)};
-      CREATE FUNCTION add_field_${sqlsanitize(f.name)}(thedef ${f.sql_bare_type}) RETURNS void AS $$
+                const q = `DROP FUNCTION IF EXISTS add_field_${(0, internal_1.sqlsanitize)(f.name)};
+      CREATE FUNCTION add_field_${(0, internal_1.sqlsanitize)(f.name)}(thedef ${f.sql_bare_type}) RETURNS void AS $$
       BEGIN
-      EXECUTE format('alter table ${schema}"${sqlsanitize(table.name)}" add column "${sqlsanitize(f.name)}" ${sql_type} ${f.required ? "not null" : ""} default %L', thedef);
+      EXECUTE format('alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}" add column "${(0, internal_1.sqlsanitize)(f.name)}" ${sql_type} ${f.required ? "not null" : ""} default %L', thedef);
       END;
       $$ LANGUAGE plpgsql;`;
-                await db.query(q);
-                await db.query(`SELECT add_field_${sqlsanitize(f.name)}($1)`, [
+                await db_1.default.query(q);
+                await db_1.default.query(`SELECT add_field_${(0, internal_1.sqlsanitize)(f.name)}($1)`, [
                     f.attributes.default,
                 ]);
             }
         }
-        f.id = await db.insert("_sc_fields", {
+        f.id = await db_1.default.insert("_sc_fields", {
             table_id: f.table_id,
             name: f.name,
             label: f.label,
-            type: f.is_fkey ? f.type : f.type.name,
+            type: f.is_fkey ? f.type : f.type?.name,
             reftable_name: f.is_fkey ? f.reftable_name : undefined,
             reftype: f.is_fkey ? f.reftype : undefined,
             refname: f.is_fkey ? f.refname : undefined,
@@ -524,7 +561,7 @@ class Field {
         });
         await require("../db/state").getState().refresh_tables();
         if (table.versioned && !f.calculated) {
-            await db.query(`alter table ${schema}"${sqlsanitize(table.name)}__history" add column "${sqlsanitize(f.name)}" ${f.sql_bare_type}`);
+            await db_1.default.query(`alter table ${schema}"${(0, internal_1.sqlsanitize)(table.name)}__history" add column "${(0, internal_1.sqlsanitize)(f.name)}" ${f.sql_bare_type}`);
         }
         if (f.is_unique && !f.calculated)
             await f.add_unique_constraint();
@@ -556,64 +593,5 @@ class Field {
             return typeattribs;
     }
 }
-Field.contract = {
-    variables: {
-        name: is.str,
-        label: is.str,
-        class: is.str,
-        postText: is.maybe(is.str),
-        sublabel: is.maybe(is.str),
-        fieldview: is.maybe(is.str),
-        parent_field: is.maybe(is.str),
-        reftable_name: is.maybe(is.str),
-        validator: is.fun(is.any, is.bool),
-        type: is.maybe(is.or(is.eq("Key"), is.eq("File"), is.obj({ name: is.str }))),
-        input_type: is.maybe(is.one_of([
-            "hidden",
-            "file",
-            "select",
-            "fromtype",
-            "search",
-            "text",
-            "password",
-            "section_header",
-            "textarea",
-            "custom_html",
-            "code",
-        ])),
-        is_fkey: is.bool,
-        is_unique: is.bool,
-        required: is.bool,
-        disabled: is.bool,
-        id: is.maybe(is.posint),
-        attributes: is.obj(),
-        table_id: is.maybe(is.posint),
-    },
-    instance_check: is.and(is.or(is.obj({ type: is.defined }), is.obj({ input_type: is.defined })), is.or(is.obj({ is_fkey: is.eq(false), reftable_name: is.eq(undefined) }), is.obj({ is_fkey: is.eq(true), reftable_name: is.str }))),
-    methods: {
-        validate: is.fun(is.obj(), is.or(is.obj({ errors: is.str }), is.obj({ success: is.any }))),
-        toJson: is.getter(is.obj({ type: is.str })),
-        sql_type: is.getter(is.str),
-        sql_bare_type: is.getter(is.str),
-        form_name: is.getter(is.str),
-        listKey: is.getter(is.any),
-        presets: is.getter(is.maybe(is.objVals(is.fun(is.obj(), is.any)))),
-        delete: is.fun([], is.promise(is.undefined)),
-        generate: is.fun([], is.promise(is.any)),
-        add_unique_constraint: is.fun([], is.promise(is.undefined)),
-        remove_unique_constraint: is.fun([], is.promise(is.undefined)),
-        toggle_not_null: is.fun(is.bool, is.promise(is.undefined)),
-        fill_table: is.fun([], is.promise(is.undefined)),
-        update: is.fun(is.obj(), is.promise(is.undefined)),
-        fill_fkey_options: is.fun(is.maybe(is.bool), is.promise()),
-        distinct_values: is.fun([], is.promise(is.array(is.obj({ label: is.any, value: is.any })))),
-    },
-    static_methods: {
-        find: is.fun([is.maybe(is.obj()), is.maybe(is.obj())], is.promise(is.array(is.class("Field")))),
-        findOne: is.fun(is.obj(), is.promise(is.class("Field"))),
-        create: is.fun(is.obj(), is.promise(is.class("Field"))),
-        labelToName: is.fun(is.str, is.str),
-    },
-};
 module.exports = Field;
 //# sourceMappingURL=field.js.map