@saltcorn/data 0.6.2-beta.5 → 0.6.3-beta.2

package/dist/models/table.js

@@ -1,20 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 /**
  * Table Database Access Layer
  * @category saltcorn-data
  * @module models/table
  * @subcategory models
  */
-const db = require("../db");
-const { sqlsanitize, mkWhere, mkSelectOptions, } = require("@saltcorn/db-common/internal");
-const Field = require("./field");
-const Trigger = require("./trigger");
+const db_1 = __importDefault(require("../db"));
+const internal_1 = require("@saltcorn/db-common/internal");
+const field_1 = __importDefault(require("./field"));
+const common_types_1 = require("@saltcorn/types/common_types");
+const trigger_1 = __importDefault(require("./trigger"));
 const { apply_calculated_fields, apply_calculated_fields_stored, recalculate_for_stored, get_expression_function, } = require("./expression");
-const { contract, is } = require("contractis");
-const { is_table_query } = require("../contracts");
-const csvtojson = require("csvtojson");
-const moment = require("moment");
-const fs = require("fs");
+const csvtojson_1 = __importDefault(require("csvtojson"));
+const moment_1 = __importDefault(require("moment"));
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const utils_1 = require("../utils");
 const { InvalidConfiguration, InvalidAdminAction, satisfies, structuredClone, getLines, } = require("../utils");
 /**
  * Transponce Objects
@@ -40,7 +44,7 @@ const transposeObjects = (objs) => {
     return res;
 };
 // todo support also other date formats https://momentjs.com/docs/
-const dateFormats = [moment.ISO_8601];
+const dateFormats = [moment_1.default.ISO_8601];
 // todo refactor - move to separated data utils module?
 /**
  * Is Valid Date of format moment.ISO_8601,
@@ -50,7 +54,7 @@ const dateFormats = [moment.ISO_8601];
  * @returns {boolean}
  */
 const isDate = function (date) {
-    return moment(date, dateFormats, true).isValid();
+    return (0, moment_1.default)(date, dateFormats, true).isValid();
 };
 // todo resolve database specific
 /**
@@ -59,7 +63,7 @@ const isDate = function (date) {
  * @returns {string}
  */
 // todo refactor
-const normalise_error_message = (msg) => db.isSQLite
+const normalise_error_message = (msg) => db_1.default.isSQLite
     ? msg.replace(/SQLITE_CONSTRAINT: UNIQUE constraint failed: (.*?)\.(.*?)/, "Duplicate value for unique field: $2")
     : msg.replace(/duplicate key value violates unique constraint "(.*?)_(.*?)_unique"/, "Duplicate value for unique field: $2");
 /**
@@ -82,8 +86,7 @@ class Table {
         this.external = false;
         this.description = o.description;
         if (o.fields)
-            this.fields = o.fields.map((f) => new Field(f));
-        contract.class(this);
+            this.fields = o.fields.map((f) => new field_1.default(f));
     }
     /**
      *
@@ -125,7 +128,7 @@ class Table {
             const { getState } = require("../db/state");
             return getState().tables.map((t) => new Table(t));
         }
-        const tbls = await db.select("_sc_tables", where, selectopts);
+        const tbls = await db_1.default.select("_sc_tables", where, selectopts);
         return tbls.map((t) => new Table(t));
     }
     /**
@@ -144,7 +147,7 @@ class Table {
         }
         if (external !== true) {
             //do include db tables
-            const tbls = await db.select("_sc_tables", where, selectopts);
+            const tbls = await db_1.default.select("_sc_tables", where, selectopts);
             dbs = tbls.map((t) => new Table(t));
         }
         return [...dbs, ...externals];
@@ -155,10 +158,10 @@ class Table {
      * @returns {null|*} null or owner column name
      */
     owner_fieldname_from_fields(fields) {
-        if (!this.ownership_field_id)
+        if (!this.ownership_field_id || !fields)
             return null;
         const field = fields.find((f) => f.id === this.ownership_field_id);
-        return field.name;
+        return field?.name;
     }
     /**
      * Get owner column name
@@ -185,7 +188,9 @@ class Table {
             return f(row, user);
         }
         const field_name = this.owner_fieldname();
-        return field_name && row[field_name] === user.id;
+        if (!field_name && this.name === "users")
+            return user && user.id && row && `${row.id}` === `${user.id}`;
+        return typeof field_name === "string" && row[field_name] === user.id;
     }
     /**
      * Create table
@@ -194,9 +199,9 @@ class Table {
      * @returns {Promise<Table>} table
      */
     static async create(name, options = {}) {
-        const schema = db.getTenantSchemaPrefix();
+        const schema = db_1.default.getTenantSchemaPrefix();
         // create table in database
-        await db.query(`create table ${schema}"${sqlsanitize(name)}" (id ${db.isSQLite ? "integer" : "serial"} primary key)`);
+        await db_1.default.query(`create table ${schema}"${(0, internal_1.sqlsanitize)(name)}" (id ${db_1.default.isSQLite ? "integer" : "serial"} primary key)`);
         // populate table definition row
         const tblrow = {
             name,
@@ -208,9 +213,9 @@ class Table {
             description: options.description || "",
         };
         // insert table defintion into _sc_tables
-        const id = await db.insert("_sc_tables", tblrow);
+        const id = await db_1.default.insert("_sc_tables", tblrow);
         // add primary key columnt ID
-        await db.query(`insert into ${schema}_sc_fields(table_id, name, label, type, attributes, required, is_unique,primary_key)
+        await db_1.default.query(`insert into ${schema}_sc_fields(table_id, name, label, type, attributes, required, is_unique,primary_key)
           values($1,'id','ID','Integer', '{}', true, true, true)`, [id]);
         // create table
         const table = new Table({ ...tblrow, id });
@@ -226,20 +231,20 @@ class Table {
      * @returns {Promise<void>}
      */
     async delete(only_forget = false) {
-        const schema = db.getTenantSchemaPrefix();
-        const is_sqlite = db.isSQLite;
+        const schema = db_1.default.getTenantSchemaPrefix();
+        const is_sqlite = db_1.default.isSQLite;
         await this.update({ ownership_field_id: null });
-        const client = is_sqlite ? db : await db.getClient();
+        const client = is_sqlite ? db_1.default : await db_1.default.getClient();
         await client.query(`BEGIN`);
         try {
             if (!only_forget)
-                await client.query(`drop table if exists ${schema}"${sqlsanitize(this.name)}"`);
+                await client.query(`drop table if exists ${schema}"${(0, internal_1.sqlsanitize)(this.name)}"`);
             await client.query(`delete FROM ${schema}_sc_fields WHERE table_id = $1`, [this.id]);
             await client.query(`delete FROM ${schema}_sc_tables WHERE id = $1`, [
                 this.id,
             ]);
             if (this.versioned)
-                await client.query(`drop table if exists ${schema}"${sqlsanitize(this.name)}__history"`);
+                await client.query(`drop table if exists ${schema}"${(0, internal_1.sqlsanitize)(this.name)}__history"`);
             await client.query(`COMMIT`);
         }
         catch (e) {
@@ -257,7 +262,7 @@ class Table {
      * @type {string}
      */
     get sql_name() {
-        return `${db.getTenantSchemaPrefix()}"${sqlsanitize(this.name)}"`;
+        return `${db_1.default.getTenantSchemaPrefix()}"${(0, internal_1.sqlsanitize)(this.name)}"`;
     }
     /**
      * Delete rows from table
@@ -266,7 +271,7 @@ class Table {
      */
     async deleteRows(where) {
         // get triggers on delete
-        const triggers = await Trigger.getTableTriggers("Delete", this);
+        const triggers = await trigger_1.default.getTableTriggers("Delete", this);
         if (triggers.length > 0) {
             const rows = await this.getRows(where);
             for (const trigger of triggers) {
@@ -276,7 +281,7 @@ class Table {
                 }
             }
         }
-        await db.deleteWhere(this.name, where);
+        await db_1.default.deleteWhere(this.name, where);
     }
     /**
      * Returns row with only fields that can be read from db (readFromDB flag)
@@ -284,9 +289,11 @@ class Table {
      * @returns {*}
      */
     readFromDB(row) {
-        for (const f of this.fields) {
-            if (f.type && f.type.readFromDB)
-                row[f.name] = f.type.readFromDB(row[f.name]);
+        if (this.fields) {
+            for (const f of this.fields) {
+                if (f.type && (0, common_types_1.instanceOfType)(f.type) && f.type.readFromDB)
+                    row[f.name] = f.type.readFromDB(row[f.name]);
+            }
         }
         return row;
     }
@@ -297,7 +304,7 @@ class Table {
      */
     async getRow(where = {}) {
         await this.getFields();
-        const row = await db.selectMaybeOne(this.name, where);
+        const row = await db_1.default.selectMaybeOne(this.name, where);
         if (!row)
             return null;
         return apply_calculated_fields([this.readFromDB(row)], this.fields)[0];
@@ -310,7 +317,7 @@ class Table {
      */
     async getRows(where = {}, selopts) {
         await this.getFields();
-        const rows = await db.select(this.name, where, selopts);
+        const rows = await db_1.default.select(this.name, where, selopts);
         return apply_calculated_fields(rows.map((r) => this.readFromDB(r)), this.fields);
     }
     /**
@@ -319,7 +326,7 @@ class Table {
      * @returns {Promise<number>}
      */
     async countRows(where) {
-        return await db.count(this.name, where);
+        return await db_1.default.count(this.name, where);
     }
     /**
      * Return distinct Values for column in table
@@ -328,7 +335,7 @@ class Table {
      * @returns {Promise<Object[]>}
      */
     async distinctValues(fieldnm) {
-        const res = await db.query(`select distinct "${db.sqlsanitize(fieldnm)}" from ${this.sql_name}`);
+        const res = await db_1.default.query(`select distinct "${db_1.default.sqlsanitize(fieldnm)}" from ${this.sql_name}`);
         return res.rows.map((r) => r[fieldnm]);
     }
     /**
@@ -344,15 +351,15 @@ class Table {
         const fields = await this.getFields();
         const pk_name = this.pk_name;
         if (fields.some((f) => f.calculated && f.stored)) {
-            existing = await db.selectOne(this.name, { [pk_name]: id });
+            existing = await db_1.default.selectOne(this.name, { [pk_name]: id });
             v = await apply_calculated_fields_stored({ ...existing, ...v_in }, this.fields);
         }
         else
             v = v_in;
         if (this.versioned) {
             if (!existing)
-                existing = await db.selectOne(this.name, { [pk_name]: id });
-            await db.insert(this.name + "__history", {
+                existing = await db_1.default.selectOne(this.name, { [pk_name]: id });
+            await db_1.default.insert(this.name + "__history", {
                 ...existing,
                 ...v,
                 [pk_name]: id,
@@ -363,14 +370,14 @@ class Table {
                 _userid,
             });
         }
-        await db.update(this.name, v, id, { pk_name });
+        await db_1.default.update(this.name, v, id, { pk_name });
         if (typeof existing === "undefined") {
-            const triggers = await Trigger.getTableTriggers("Update", this);
+            const triggers = await trigger_1.default.getTableTriggers("Update", this);
             if (triggers.length > 0)
-                existing = await db.selectOne(this.name, { [pk_name]: id });
+                existing = await db_1.default.selectOne(this.name, { [pk_name]: id });
         }
         const newRow = { ...existing, ...v, [pk_name]: id };
-        await Trigger.runTableTriggers("Update", this, newRow);
+        await trigger_1.default.runTableTriggers("Update", this, newRow);
     }
     /**
      * Try to Update row
@@ -395,11 +402,13 @@ class Table {
      * @returns {Promise<void>}
      */
     async toggleBool(id, field_name) {
-        const schema = db.getTenantSchemaPrefix();
-        await db.query(`update ${schema}"${sqlsanitize(this.name)}" set "${sqlsanitize(field_name)}"=NOT coalesce("${sqlsanitize(field_name)}", false) where id=$1`, [id]);
-        const triggers = await Trigger.getTableTriggers("Update", this);
+        const schema = db_1.default.getTenantSchemaPrefix();
+        await db_1.default.query(`update ${schema}"${(0, internal_1.sqlsanitize)(this.name)}" set "${(0, internal_1.sqlsanitize)(field_name)}"=NOT coalesce("${(0, internal_1.sqlsanitize)(field_name)}", false) where id=$1`, [id]);
+        const triggers = await trigger_1.default.getTableTriggers("Update", this);
         if (triggers.length > 0) {
             const row = await this.getRow({ id });
+            if (!row)
+                throw new Error(`Unable to find row with id: ${id}`);
             for (const trigger of triggers) {
                 await trigger.run(row);
             }
@@ -410,7 +419,11 @@ class Table {
      * @type {string}
      */
     get pk_name() {
-        return this.fields.find((f) => f.primary_key).name;
+        const pkField = this.fields?.find((f) => f.primary_key)?.name;
+        if (!pkField) {
+            throw new Error("A primary key field is mandatory");
+        }
+        return pkField;
     }
     /**
      * Insert row
@@ -422,16 +435,16 @@ class Table {
         await this.getFields();
         const v = await apply_calculated_fields_stored(v_in, this.fields);
         const pk_name = this.pk_name;
-        const id = await db.insert(this.name, v, { pk_name });
+        const id = await db_1.default.insert(this.name, v, { pk_name });
         if (this.versioned)
-            await db.insert(this.name + "__history", {
+            await db_1.default.insert(this.name + "__history", {
                 ...v,
                 [pk_name]: id,
                 _version: 1,
                 _userid,
                 _time: new Date(),
             });
-        Trigger.runTableTriggers("Insert", this, { [pk_name]: id, ...v });
+        trigger_1.default.runTableTriggers("Insert", this, { [pk_name]: id, ...v });
         return id;
     }
     /**
@@ -455,7 +468,10 @@ class Table {
      */
     async getFields() {
         if (!this.fields) {
-            this.fields = await Field.find({ table_id: this.id }, { orderBy: "id" });
+            this.fields = await field_1.default.find({ table_id: this.id }, { orderBy: "id" });
+            for (let field of this.fields) {
+                field.table = this;
+            }
         }
         return this.fields;
     }
@@ -465,12 +481,15 @@ class Table {
      */
     // todo create function that returns history table name for table
     async create_history_table() {
-        const schemaPrefix = db.getTenantSchemaPrefix();
+        const schemaPrefix = db_1.default.getTenantSchemaPrefix();
         const fields = await this.getFields();
-        const flds = fields.map((f) => `,"${sqlsanitize(f.name)}" ${f.sql_bare_type}`);
-        const pk = fields.find((f) => f.primary_key).name;
+        const flds = fields.map((f) => `,"${(0, internal_1.sqlsanitize)(f.name)}" ${f.sql_bare_type}`);
+        const pk = fields.find((f) => f.primary_key)?.name;
+        if (!pk) {
+            throw new Error("Unable to find a field with a primary key.");
+        }
         // create history table
-        await db.query(`create table ${schemaPrefix}"${sqlsanitize(this.name)}__history" (
+        await db_1.default.query(`create table ${schemaPrefix}"${(0, internal_1.sqlsanitize)(this.name)}__history" (
           _version integer,
           _time timestamp,
           _userid integer
@@ -483,9 +502,9 @@ class Table {
      * @returns {Promise<void>}
      */
     async drop_history_table() {
-        const schemaPrefix = db.getTenantSchemaPrefix();
-        await db.query(`
-      drop table ${schemaPrefix}"${sqlsanitize(this.name)}__history";`);
+        const schemaPrefix = db_1.default.getTenantSchemaPrefix();
+        await db_1.default.query(`
+      drop table ${schemaPrefix}"${(0, internal_1.sqlsanitize)(this.name)}__history";`);
     }
     /**
      * Rename table
@@ -494,19 +513,19 @@ class Table {
      */
     async rename(new_name) {
         //in transaction
-        if (db.isSQLite)
+        if (db_1.default.isSQLite)
             throw new InvalidAdminAction("Cannot rename table on SQLite");
-        const schemaPrefix = db.getTenantSchemaPrefix();
-        const client = await db.getClient();
+        const schemaPrefix = db_1.default.getTenantSchemaPrefix();
+        const client = await db_1.default.getClient();
         await client.query(`BEGIN`);
         try {
             //rename table
-            await db.query(`alter table ${schemaPrefix}"${sqlsanitize(this.name)}" rename to "${sqlsanitize(new_name)}";`);
+            await db_1.default.query(`alter table ${schemaPrefix}"${(0, internal_1.sqlsanitize)(this.name)}" rename to "${(0, internal_1.sqlsanitize)(new_name)}";`);
             //change refs
-            await db.query(`update ${schemaPrefix}_sc_fields set reftable_name=$1 where reftable_name=$2`, [sqlsanitize(new_name), sqlsanitize(this.name)]);
+            await db_1.default.query(`update ${schemaPrefix}_sc_fields set reftable_name=$1 where reftable_name=$2`, [(0, internal_1.sqlsanitize)(new_name), (0, internal_1.sqlsanitize)(this.name)]);
             //rename history
             if (this.versioned)
-                await db.query(`alter table ${schemaPrefix}"${sqlsanitize(this.name)}__history" rename to "${sqlsanitize(new_name)}__history";`);
+                await db_1.default.query(`alter table ${schemaPrefix}"${(0, internal_1.sqlsanitize)(this.name)}__history" rename to "${(0, internal_1.sqlsanitize)(new_name)}__history";`);
             //1. change record
             await this.update({ name: new_name });
             await client.query(`COMMIT`);
@@ -529,17 +548,25 @@ class Table {
         if (new_table_rec.ownership_field_id === "")
             delete new_table_rec.ownership_field_id;
         const existing = await Table.findOne({ id: this.id });
+        if (!existing) {
+            throw new Error(`Unable to find table with id: ${this.id}`);
+        }
         const { external, fields, ...upd_rec } = new_table_rec;
-        await db.update("_sc_tables", upd_rec, this.id);
+        await db_1.default.update("_sc_tables", upd_rec, this.id);
         await require("../db/state").getState().refresh_tables();
         const new_table = await Table.findOne({ id: this.id });
-        if (new_table.versioned && !existing.versioned) {
-            await new_table.create_history_table();
+        if (!new_table) {
+            throw new Error(`Unable to find table with id: ${this.id}`);
         }
-        else if (!new_table.versioned && existing.versioned) {
-            await new_table.drop_history_table();
+        else {
+            if (new_table.versioned && !existing.versioned) {
+                await new_table.create_history_table();
+            }
+            else if (!new_table.versioned && existing.versioned) {
+                await new_table.drop_history_table();
+            }
+            Object.assign(this, new_table_rec);
         }
-        Object.assign(this, new_table_rec);
     }
     /**
      * Get table history data
@@ -547,7 +574,7 @@ class Table {
      * @returns {Promise<*>}
      */
     async get_history(id) {
-        return await db.select(`${sqlsanitize(this.name)}__history`, { id }, { orderBy: "_version" });
+        return await db_1.default.select(`${(0, internal_1.sqlsanitize)(this.name)}__history`, { id }, { orderBy: "_version" });
     }
     /**
      * Enable constraints
@@ -568,7 +595,7 @@ class Table {
         let rows;
         try {
             const s = await getLines(filePath, 500);
-            rows = await csvtojson().fromString(s); // todo agrument type unknown
+            rows = await (0, csvtojson_1.default)().fromString(s); // todo agrument type unknown
         }
         catch (e) {
             return { error: `Error processing CSV file` };
@@ -595,14 +622,14 @@ class Table {
                 type = "String";
             const label = (k.charAt(0).toUpperCase() + k.slice(1)).replace(/_/g, " ");
             //can fail here if: non integer i d, duplicate headers, invalid name
-            const fld = new Field({
-                name: Field.labelToName(k),
+            const fld = new field_1.default({
+                name: field_1.default.labelToName(k),
                 required,
                 type,
                 table,
                 label,
             });
-            if (db.sqlsanitize(k.toLowerCase()) === "id") {
+            if (db_1.default.sqlsanitize(k.toLowerCase()) === "id") {
                 if (type !== "Integer") {
                     await table.delete();
                     return { error: `Columns named "id" must have only integers` };
@@ -613,14 +640,14 @@ class Table {
                 }
                 continue;
             }
-            if (db.sqlsanitize(fld.name) === "") {
+            if (db_1.default.sqlsanitize(fld.name) === "") {
                 await table.delete();
                 return {
                     error: `Invalid column name ${k} - Use A-Z, a-z, 0-9, _ only`,
                 };
             }
             try {
-                await Field.create(fld);
+                await field_1.default.create(fld);
             }
             catch (e) {
                 await table.delete();
@@ -628,7 +655,7 @@ class Table {
             }
         }
         const parse_res = await table.import_csv_file(filePath);
-        if (parse_res.error) {
+        if ((0, common_types_1.instanceOfErrorMsg)(parse_res)) {
             await table.delete();
             return { error: parse_res.error };
         }
@@ -648,7 +675,7 @@ class Table {
         const { readStateStrict } = require("../plugin-helper");
         try {
             const s = await getLines(filePath, 1);
-            [headers] = await csvtojson({
+            [headers] = await (0, csvtojson_1.default)({
                 output: "csv",
                 noheader: true,
             }).fromString(s); // todo agrument type unknown
@@ -680,15 +707,15 @@ class Table {
         const colRe = new RegExp(`(${Object.keys(okHeaders).join("|")})`);
         let i = 1;
         let rejects = 0;
-        const client = db.isSQLite ? db : await db.getClient();
-        const stats = await fs.promises.stat(filePath);
+        const client = db_1.default.isSQLite ? db_1.default : await db_1.default.getClient();
+        const stats = await (0, promises_1.stat)(filePath);
         const fileSizeInMegabytes = stats.size / (1024 * 1024);
         await client.query("BEGIN");
-        const readStream = fs.createReadStream(filePath);
+        const readStream = (0, fs_1.createReadStream)(filePath);
         try {
-            if (db.copyFrom && fileSizeInMegabytes > 1) {
+            if (db_1.default.copyFrom && fileSizeInMegabytes > 1) {
                 let theError;
-                const copyres = await db
+                const copyres = await db_1.default
                     .copyFrom(readStream, this.name, fieldNames, client)
                     .catch((cate) => {
                     theError = cate;
@@ -704,7 +731,7 @@ class Table {
             }
             else {
                 await new Promise((resolve, reject) => {
-                    csvtojson({
+                    (0, csvtojson_1.default)({
                         includeColumns: colRe,
                     })
                         .fromStream(readStream)
@@ -719,7 +746,7 @@ class Table {
                             });
                             const rowOk = readStateStrict(rec, fields);
                             if (rowOk)
-                                await db.insert(this.name, rec, {
+                                await db_1.default.insert(this.name, rec, {
                                     noid: true,
                                     client,
                                     pk_name,
@@ -729,7 +756,7 @@ class Table {
                         }
                         catch (e) {
                             await client.query("ROLLBACK");
-                            if (!db.isSQLite)
+                            if (!db_1.default.isSQLite)
                                 await client.release(true);
                             reject({ error: `${e.message} in row ${i}` });
                         }
@@ -748,12 +775,19 @@ class Table {
             };
         }
         await client.query("COMMIT");
-        if (!db.isSQLite)
+        if (!db_1.default.isSQLite)
             await client.release(true);
         const pk = fields.find((f) => f.primary_key);
-        if (db.reset_sequence && pk.type.name === "Integer")
-            await db.reset_sequence(this.name);
-        if (recalc_stored && this.fields.some((f) => f.calculated && f.stored)) {
+        if (!pk) {
+            throw new Error("Unable to find a field with a primary key.");
+        }
+        if (db_1.default.reset_sequence &&
+            (0, common_types_1.instanceOfType)(pk.type) &&
+            pk.type.name === "Integer")
+            await db_1.default.reset_sequence(this.name);
+        if (recalc_stored &&
+            this.fields &&
+            this.fields.some((f) => f.calculated && f.stored)) {
             await recalculate_for_stored(this);
         }
         return {
@@ -768,12 +802,12 @@ class Table {
      */
     async import_json_file(filePath, skip_first_data_row) {
         // todo argument type buffer is not assignable for type String...
-        const file_rows = JSON.parse(await fs.promises.readFile(filePath));
+        const file_rows = JSON.parse(await (await (0, promises_1.readFile)(filePath)).toString());
         const fields = await this.getFields();
         const pk_name = this.pk_name;
         const { readState } = require("../plugin-helper");
         let i = 1;
-        const client = db.isSQLite ? db : await db.getClient();
+        const client = db_1.default.isSQLite ? db_1.default : await db_1.default.getClient();
         await client.query("BEGIN");
         for (const rec of file_rows) {
             i += 1;
@@ -788,21 +822,25 @@ class Table {
             });
             try {
                 readState(rec, fields);
-                await db.insert(this.name, rec, { noid: true, client, pk_name });
+                await db_1.default.insert(this.name, rec, { noid: true, client, pk_name });
             }
             catch (e) {
                 await client.query("ROLLBACK");
-                if (!db.isSQLite)
+                if (!db_1.default.isSQLite)
                     await client.release(true);
                 return { error: `${e.message} in row ${i}` };
             }
         }
         await client.query("COMMIT");
-        if (!db.isSQLite)
+        if (!db_1.default.isSQLite)
             await client.release(true);
         const pk = fields.find((f) => f.primary_key);
-        if (db.reset_sequence && pk.type.name === "Integer")
-            await db.reset_sequence(this.name);
+        if (!pk)
+            throw new Error("Unable to find a primary key field.");
+        if (db_1.default.reset_sequence &&
+            (0, common_types_1.instanceOfType)(pk.type) &&
+            pk.type.name === "Integer")
+            await db_1.default.reset_sequence(this.name);
         return {
             success: `Imported ${file_rows.length} rows into table ${this.name}`,
         };
@@ -819,21 +857,47 @@ class Table {
         for (const f of fields) {
             if (f.is_fkey && f.type !== "File") {
                 const table = await Table.findOne({ name: f.reftable_name });
+                if (!table)
+                    throw new Error(`Unable to find table '${f.reftable_name}`);
                 await table.getFields();
+                if (!table.fields)
+                    throw new Error(`The table '${f.reftable_name} has no fields.`);
                 for (const pf of table.fields.filter((f) => !f.calculated || f.stored)) {
                     parent_field_list.push(`${f.name}.${pf.name}`);
                     if (pf.is_fkey && pf.type !== "File" && allow_double) {
                         const table1 = await Table.findOne({ name: pf.reftable_name });
+                        if (!table1)
+                            throw new Error(`Unable to find table '${pf.reftable_name}`);
                         await table1.getFields();
-                        for (const gpf of table1.fields.filter((f) => !f.calculated || f.stored)) {
-                            parent_field_list.push(`${f.name}.${pf.name}.${gpf.name}`);
-                        }
+                        if (!table1.fields)
+                            throw new Error(`The table '${pf.reftable_name} has no fields.`);
+                        if (table1.fields)
+                            for (const gpf of table1.fields.filter((f) => !f.calculated || f.stored)) {
+                                parent_field_list.push(`${f.name}.${pf.name}.${gpf.name}`);
+                            }
                         parent_relations.push({ key_field: pf, through: f, table: table1 });
                     }
                 }
                 parent_relations.push({ key_field: f, table });
             }
         }
+        const o2o_rels = await field_1.default.find({
+            reftable_name: this.name,
+            is_unique: true,
+        });
+        for (const relation of o2o_rels) {
+            const related_table = await Table.findOne({ id: relation.table_id });
+            if (related_table) {
+                const relfields = await related_table.getFields();
+                for (const relfield of relfields) {
+                    parent_field_list.push(`${related_table.name}.${relation.name}->${relfield.name}`);
+                    parent_relations.push({
+                        key_field: relation,
+                        ontable: related_table,
+                    });
+                }
+            }
+        }
         return { parent_relations, parent_field_list };
     }
     /**
@@ -841,12 +905,15 @@ class Table {
      * @returns {Promise<{child_relations: object[], child_field_list: object[]}>}
      */
     async get_child_relations() {
-        const cfields = await Field.find({ reftable_name: this.name });
+        const cfields = await field_1.default.find({ reftable_name: this.name });
         let child_relations = [];
         let child_field_list = [];
         for (const f of cfields) {
             if (f.is_fkey) {
                 const table = await Table.findOne({ id: f.table_id });
+                if (!table) {
+                    throw new Error(`Unable to find table with id: ${f.table_id}`);
+                }
                 child_field_list.push(`${table.name}.${f.name}`);
                 await table.getFields();
                 child_relations.push({ key_field: f, table });
@@ -865,7 +932,7 @@ class Table {
         let joinq = "";
         let joinTables = [];
         let joinFields = opts.joinFields || [];
-        const schema = db.getTenantSchemaPrefix();
+        const schema = db_1.default.getTenantSchemaPrefix();
         fields
             .filter((f) => f.type === "File")
             .forEach((f) => {
@@ -875,17 +942,29 @@ class Table {
                 target: `filename`,
             };
         });
-        for (const [fldnm, { ref, target, through }] of Object.entries(joinFields)) {
-            const reffield = fields.find((f) => f.name === ref);
+        for (const [fldnm, { ref, target, through, ontable }] of Object.entries(joinFields)) {
+            let reffield;
+            if (ontable) {
+                const ontableTbl = Table.findOne({ name: ontable });
+                if (!ontableTbl)
+                    throw new InvalidConfiguration(`Related table ${ontable} not found in table ${this.name}`);
+                reffield = (await ontableTbl.getFields()).find((f) => f.name === ref);
+            }
+            else {
+                reffield = fields.find((f) => f.name === ref);
+            }
             if (!reffield)
                 throw new InvalidConfiguration(`Key field ${ref} not found in table ${this.name}`);
-            const reftable = reffield.reftable_name;
+            const reftable = ontable || reffield.reftable_name;
             if (!reftable)
                 throw new InvalidConfiguration(`Field ${ref} is not a key field`);
-            const jtNm = `${sqlsanitize(reftable)}_jt_${sqlsanitize(ref)}`;
+            const jtNm = `${(0, internal_1.sqlsanitize)(reftable)}_jt_${(0, internal_1.sqlsanitize)(ref)}`;
             if (!joinTables.includes(jtNm)) {
                 joinTables.push(jtNm);
-                joinq += ` left join ${schema}"${sqlsanitize(reftable)}" ${jtNm} on ${jtNm}."${reffield.refname}"=a."${sqlsanitize(ref)}"`;
+                if (ontable)
+                    joinq += ` left join ${schema}"${(0, internal_1.sqlsanitize)(reftable)}" ${jtNm} on ${jtNm}."${(0, internal_1.sqlsanitize)(ref)}"=a."${reffield.refname}"`;
+                else
+                    joinq += ` left join ${schema}"${(0, internal_1.sqlsanitize)(reftable)}" ${jtNm} on ${jtNm}."${reffield.refname}"=a."${(0, internal_1.sqlsanitize)(ref)}"`;
             }
             if (through) {
                 const throughTable = await Table.findOne({
@@ -898,48 +977,42 @@ class Table {
                 if (!throughRefField)
                     throw new InvalidConfiguration(`Reference field field ${through} not found in table ${throughTable.name}`);
                 const finalTable = throughRefField.reftable_name;
-                const jtNm1 = `${sqlsanitize(reftable)}_jt_${sqlsanitize(through)}_jt_${sqlsanitize(ref)}`;
+                const jtNm1 = `${(0, internal_1.sqlsanitize)(reftable)}_jt_${(0, internal_1.sqlsanitize)(through)}_jt_${(0, internal_1.sqlsanitize)(ref)}`;
                 if (!joinTables.includes(jtNm1)) {
+                    if (!finalTable)
+                        throw new Error("Unable to build a joind without a reftable_name.");
                     joinTables.push(jtNm1);
-                    joinq += ` left join ${schema}"${sqlsanitize(finalTable)}" ${jtNm1} on ${jtNm1}.id=${jtNm}."${sqlsanitize(through)}"`;
+                    joinq += ` left join ${schema}"${(0, internal_1.sqlsanitize)(finalTable)}" ${jtNm1} on ${jtNm1}.id=${jtNm}."${(0, internal_1.sqlsanitize)(through)}"`;
                 }
-                fldNms.push(`${jtNm1}.${sqlsanitize(target)} as ${sqlsanitize(fldnm)}`);
+                fldNms.push(`${jtNm1}.${(0, internal_1.sqlsanitize)(target)} as ${(0, internal_1.sqlsanitize)(fldnm)}`);
             }
             else {
-                fldNms.push(`${jtNm}.${sqlsanitize(target)} as ${sqlsanitize(fldnm)}`);
+                fldNms.push(`${jtNm}.${(0, internal_1.sqlsanitize)(target)} as ${(0, internal_1.sqlsanitize)(fldnm)}`);
             }
         }
         for (const f of fields.filter((f) => !f.calculated || f.stored)) {
-            fldNms.push(`a."${sqlsanitize(f.name)}"`);
+            fldNms.push(`a."${(0, internal_1.sqlsanitize)(f.name)}"`);
         }
         Object.entries(opts.aggregations || {}).forEach(([fldnm, { table, ref, field, where, aggregate, subselect }]) => {
             if (aggregate.startsWith("Latest ")) {
                 const dateField = aggregate.replace("Latest ", "");
-                fldNms.push(`(select "${sqlsanitize(field)}" from ${schema}"${sqlsanitize(table)}" where ${dateField}=(select max(${dateField}) from ${schema}"${sqlsanitize(table)}" where "${sqlsanitize(ref)}"=a.id${where ? ` and ${where}` : ""}) and "${sqlsanitize(ref)}"=a.id) ${sqlsanitize(fldnm)}`);
+                fldNms.push(`(select "${(0, internal_1.sqlsanitize)(field)}" from ${schema}"${(0, internal_1.sqlsanitize)(table)}" where ${dateField}=(select max(${dateField}) from ${schema}"${(0, internal_1.sqlsanitize)(table)}" where "${(0, internal_1.sqlsanitize)(ref)}"=a.id${where ? ` and ${where}` : ""}) and "${(0, internal_1.sqlsanitize)(ref)}"=a.id) ${(0, internal_1.sqlsanitize)(fldnm)}`);
             }
             else if (subselect)
-                fldNms.push(`(select ${sqlsanitize(aggregate)}(${field ? `"${sqlsanitize(field)}"` : "*"}) from ${schema}"${sqlsanitize(table)}" where ${sqlsanitize(ref)} in (select "${subselect.field}" from ${schema}"${subselect.table.name}" where "${subselect.whereField}"=a.id)) ${sqlsanitize(fldnm)}`);
+                fldNms.push(`(select ${(0, internal_1.sqlsanitize)(aggregate)}(${field ? `"${(0, internal_1.sqlsanitize)(field)}"` : "*"}) from ${schema}"${(0, internal_1.sqlsanitize)(table)}" where ${(0, internal_1.sqlsanitize)(ref)} in (select "${subselect.field}" from ${schema}"${subselect.table.name}" where "${subselect.whereField}"=a.id)) ${(0, internal_1.sqlsanitize)(fldnm)}`);
             else
-                fldNms.push(`(select ${sqlsanitize(aggregate)}(${field ? `"${sqlsanitize(field)}"` : "*"}) from ${schema}"${sqlsanitize(table)}" where "${sqlsanitize(ref)}"=a.id${where ? ` and ${where}` : ""}) ${sqlsanitize(fldnm)}`);
+                fldNms.push(`(select ${(0, internal_1.sqlsanitize)(aggregate)}(${field ? `"${(0, internal_1.sqlsanitize)(field)}"` : "*"}) from ${schema}"${(0, internal_1.sqlsanitize)(table)}" where "${(0, internal_1.sqlsanitize)(ref)}"=a.id${where ? ` and ${where}` : ""}) ${(0, internal_1.sqlsanitize)(fldnm)}`);
         });
-        let whereObj = {};
-        if (opts.where) {
-            Object.keys(opts.where).forEach((k) => {
-                if (k === "_fts")
-                    whereObj[k] = { table: "a", ...opts.where[k] };
-                else
-                    whereObj[`a."${k}"`] = opts.where[k];
-            });
-        }
-        const { where, values } = mkWhere(whereObj, db.isSQLite);
+        const whereObj = (0, utils_1.prefixFieldsInWhere)(opts.where, "a");
+        const { where, values } = (0, internal_1.mkWhere)(whereObj, db_1.default.isSQLite);
         const selectopts = {
             limit: opts.limit,
             orderBy: opts.orderBy &&
-                (opts.orderBy.distance ? opts.orderBy : "a." + opts.orderBy),
+                ((0, internal_1.orderByIsObject)(opts.orderBy) ? opts.orderBy : "a." + opts.orderBy),
             orderDesc: opts.orderDesc,
             offset: opts.offset,
         };
-        const sql = `SELECT ${fldNms.join()} FROM ${schema}"${sqlsanitize(this.name)}" a ${joinq} ${where}  ${mkSelectOptions(selectopts)}`;
+        const sql = `SELECT ${fldNms.join()} FROM ${schema}"${(0, internal_1.sqlsanitize)(this.name)}" a ${joinq} ${where}  ${(0, internal_1.mkSelectOptions)(selectopts)}`;
         return { sql, values };
     }
     /**
@@ -949,58 +1022,41 @@ class Table {
     async getJoinedRows(opts = {}) {
         const fields = await this.getFields();
         const { sql, values } = await this.getJoinedQuery(opts);
-        const res = await db.query(sql, values);
+        const res = await db_1.default.query(sql, values);
         return apply_calculated_fields(res.rows, fields);
     }
+    async slug_options() {
+        const fields = await this.getFields();
+        const unique_fields = fields.filter((f) => f.is_unique);
+        const opts = [];
+        unique_fields.forEach((f) => {
+            const label = (0, common_types_1.instanceOfType)(f.type) && f.type.name === "String"
+                ? `/slugify-${f.name}`
+                : `/:${f.name}`;
+            opts.push({
+                label,
+                steps: [
+                    {
+                        field: f.name,
+                        unique: true,
+                        transform: (0, common_types_1.instanceOfType)(f.type) && f.type.name === "String"
+                            ? "slugify"
+                            : null,
+                    },
+                ],
+            });
+        });
+        opts.unshift({ label: "", steps: [] });
+        return opts;
+    }
+    static async allSlugOptions() {
+        const tables = await Table.find({});
+        const options = {};
+        for (const table of tables) {
+            options[table.name] = await table.slug_options();
+        }
+        return options;
+    }
 }
-/**
- * Table contract
- * @type {{variables: {name: ((function(*=): *)|*)}, methods: {updateRow: ((function(*=): *)|*), get_history: ((function(*=): *)|*), tryUpdateRow: ((function(*=): *)|*), deleteRows: ((function(*=): *)|*), update: ((function(*=): *)|*), getRows: ((function(*=): *)|*), getRow: ((function(*=): *)|*), delete: ((function(*=): *)|*), get_parent_relations: ((function(*=): *)|*), get_child_relations: ((function(*=): *)|*), tryInsertRow: ((function(*=): *)|*), getFields: ((function(*=): *)|*), insertRow: ((function(*=): *)|*), toggleBool: ((function(*=): *)|*), getJoinedRows: ((function(*=): *)|*), countRows: ((function(*=): *)|*), distinctValues: ((function(*=): *)|*), sql_name: ((function(*=): *)|*), import_csv_file: ((function(*=): *)|*)}, static_methods: {find: ((function(*=): *)|*), create_from_csv: ((function(*=): *)|*), findOne: ((function(*=): *)|*), find_with_external: ((function(*=): *)|*), create: ((function(*=): *)|*)}, constructs: {name: ((function(*=): *)|*)}}}
- */
-Table.contract = {
-    constructs: { name: is.str },
-    variables: { name: is.str },
-    methods: {
-        delete: is.fun([], is.promise(is.eq(undefined))),
-        update: is.fun(is.obj(), is.promise(is.eq(undefined))),
-        deleteRows: is.fun(is.obj(), is.promise(is.eq(undefined))),
-        getRow: is.fun(is.maybe(is.obj()), is.promise(is.maybe(is.obj()))),
-        getRows: is.fun(is.maybe(is.obj()), is.promise(is.array(is.obj()))),
-        countRows: is.fun(is.maybe(is.obj()), is.promise(is.posint)),
-        updateRow: is.fun([is.obj(), is.any], is.promise(is.eq(undefined))),
-        toggleBool: is.fun([is.any, is.str], is.promise(is.eq(undefined))),
-        insertRow: is.fun(is.obj(), is.promise(is.any)),
-        get_history: is.fun(is.posint, is.promise(is.array(is.obj()))),
-        distinctValues: is.fun(is.str, is.promise(is.array(is.any))),
-        tryInsertRow: is.fun([is.obj(), is.maybe(is.posint)], is.promise(is.or(is.obj({ error: is.str }), is.obj({ success: is.any })))),
-        tryUpdateRow: is.fun([is.obj(), is.any, is.maybe(is.posint)], is.promise(is.or(is.obj({ error: is.str }), is.obj({ success: is.eq(true) })))),
-        sql_name: is.getter(is.str),
-        getFields: is.fun([], is.promise(is.array(is.class("Field")))),
-        get_parent_relations: is.fun([], is.promise(is.obj({
-            parent_relations: is.array(is.obj({
-                key_field: is.class("Field"),
-                table: is.class("Table"),
-            })),
-            parent_field_list: is.array(is.str),
-        }))),
-        get_child_relations: is.fun([], is.promise(is.obj({
-            child_relations: is.array(is.obj({
-                key_field: is.class("Field"),
-                table: is.class("Table"),
-            })),
-            child_field_list: is.array(is.str),
-        }))),
-        import_csv_file: is.fun(is.str, is.promise(is.or(is.obj({ success: is.str }), is.obj({ error: is.str })))),
-        getJoinedRows: is.fun(is.maybe(is_table_query), is.promise(is.array(is.obj({})))),
-    },
-    static_methods: {
-        find: is.fun([is.maybe(is.obj()), is.maybe(is.obj())], is.promise(is.array(is.class("Table")))),
-        find_with_external: is.fun([is.maybe(is.obj()), is.maybe(is.obj())], is.promise(is.array(is.or(is.class("Table"), is.obj({ external: is.eq(true) }))))),
-        findOne: is.fun(is.or(is.obj(), is.str, is.posint), is.maybe(is.or(is.class("Table"), is.obj({ external: is.eq(true) })))),
-        create: is.fun(is.str, is.promise(is.class("Table"))),
-        create_from_csv: is.fun([is.str, is.str], is.promise(is.or(is.obj({ success: is.str, table: is.class("Table") }), is.obj({ error: is.str })))),
-        //update: is.fun([is.posint, is.obj({})], is.promise(is.eq(undefined)))
-    },
-};
 module.exports = Table;
 //# sourceMappingURL=table.js.map