@budibase/backend-core 3.2.11 → 3.2.16

package/dist/index.js

@@ -14084,7 +14084,7 @@ var DDInstrumentedDatabase = class {
   }
   exists(docId) {
     return import_dd_trace.default.trace("db.exists", (span) => {
-      span?.addTags({ db_name: this.name, doc_id: docId });
+      span.addTags({ db_name: this.name, doc_id: docId });
       if (docId) {
         return this.db.exists(docId);
       }
@@ -14093,122 +14093,167 @@ var DDInstrumentedDatabase = class {
   }
   get(id) {
     return import_dd_trace.default.trace("db.get", (span) => {
-      span?.addTags({ db_name: this.name, doc_id: id });
+      span.addTags({ db_name: this.name, doc_id: id });
       return this.db.get(id);
     });
   }
   tryGet(id) {
-    return import_dd_trace.default.trace("db.tryGet", (span) => {
-      span?.addTags({ db_name: this.name, doc_id: id });
-      return this.db.tryGet(id);
+    return import_dd_trace.default.trace("db.tryGet", async (span) => {
+      span.addTags({ db_name: this.name, doc_id: id });
+      const doc = await this.db.tryGet(id);
+      span.addTags({ doc_found: doc !== void 0 });
+      return doc;
     });
   }
   getMultiple(ids, opts) {
-    return import_dd_trace.default.trace("db.getMultiple", (span) => {
-      span?.addTags({
+    return import_dd_trace.default.trace("db.getMultiple", async (span) => {
+      span.addTags({
         db_name: this.name,
         num_docs: ids.length,
         allow_missing: opts?.allowMissing
       });
-      return this.db.getMultiple(ids, opts);
+      const docs = await this.db.getMultiple(ids, opts);
+      span.addTags({ num_docs_found: docs.length });
+      return docs;
     });
   }
   remove(idOrDoc, rev) {
-    return import_dd_trace.default.trace("db.remove", (span) => {
-      span?.addTags({ db_name: this.name, doc_id: idOrDoc });
+    return import_dd_trace.default.trace("db.remove", async (span) => {
+      span.addTags({ db_name: this.name, doc_id: idOrDoc, rev });
       const isDocument2 = typeof idOrDoc === "object";
       const id = isDocument2 ? idOrDoc._id : idOrDoc;
       rev = isDocument2 ? idOrDoc._rev : rev;
-      return this.db.remove(id, rev);
+      const resp = await this.db.remove(id, rev);
+      span.addTags({ ok: resp.ok });
+      return resp;
     });
   }
   bulkRemove(documents, opts) {
     return import_dd_trace.default.trace("db.bulkRemove", (span) => {
-      span?.addTags({ db_name: this.name, num_docs: documents.length });
+      span.addTags({
+        db_name: this.name,
+        num_docs: documents.length,
+        silence_errors: opts?.silenceErrors
+      });
       return this.db.bulkRemove(documents, opts);
     });
   }
   put(document, opts) {
-    return import_dd_trace.default.trace("db.put", (span) => {
-      span?.addTags({ db_name: this.name, doc_id: document._id });
-      return this.db.put(document, opts);
+    return import_dd_trace.default.trace("db.put", async (span) => {
+      span.addTags({
+        db_name: this.name,
+        doc_id: document._id,
+        force: opts?.force
+      });
+      const resp = await this.db.put(document, opts);
+      span.addTags({ ok: resp.ok });
+      return resp;
     });
   }
   bulkDocs(documents) {
     return import_dd_trace.default.trace("db.bulkDocs", (span) => {
-      span?.addTags({ db_name: this.name, num_docs: documents.length });
+      span.addTags({ db_name: this.name, num_docs: documents.length });
       return this.db.bulkDocs(documents);
     });
   }
   allDocs(params2) {
-    return import_dd_trace.default.trace("db.allDocs", (span) => {
-      span?.addTags({ db_name: this.name });
-      return this.db.allDocs(params2);
+    return import_dd_trace.default.trace("db.allDocs", async (span) => {
+      span.addTags({ db_name: this.name, ...params2 });
+      const resp = await this.db.allDocs(params2);
+      span.addTags({
+        total_rows: resp.total_rows,
+        rows_length: resp.rows.length,
+        offset: resp.offset
+      });
+      return resp;
     });
   }
   query(viewName, params2) {
-    return import_dd_trace.default.trace("db.query", (span) => {
-      span?.addTags({ db_name: this.name, view_name: viewName });
-      return this.db.query(viewName, params2);
+    return import_dd_trace.default.trace("db.query", async (span) => {
+      span.addTags({ db_name: this.name, view_name: viewName, ...params2 });
+      const resp = await this.db.query(viewName, params2);
+      span.addTags({
+        total_rows: resp.total_rows,
+        rows_length: resp.rows.length,
+        offset: resp.offset
+      });
+      return resp;
     });
   }
   destroy() {
-    return import_dd_trace.default.trace("db.destroy", (span) => {
-      span?.addTags({ db_name: this.name });
-      return this.db.destroy();
+    return import_dd_trace.default.trace("db.destroy", async (span) => {
+      span.addTags({ db_name: this.name });
+      const resp = await this.db.destroy();
+      span.addTags({ ok: resp.ok });
+      return resp;
     });
   }
   compact() {
-    return import_dd_trace.default.trace("db.compact", (span) => {
-      span?.addTags({ db_name: this.name });
-      return this.db.compact();
+    return import_dd_trace.default.trace("db.compact", async (span) => {
+      span.addTags({ db_name: this.name });
+      const resp = await this.db.compact();
+      span.addTags({ ok: resp.ok });
+      return resp;
     });
   }
   dump(stream3, opts) {
     return import_dd_trace.default.trace("db.dump", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({
+        db_name: this.name,
+        batch_limit: opts?.batch_limit,
+        batch_size: opts?.batch_size,
+        style: opts?.style,
+        timeout: opts?.timeout,
+        num_doc_ids: opts?.doc_ids?.length,
+        view: opts?.view
+      });
       return this.db.dump(stream3, opts);
     });
   }
   load(...args) {
     return import_dd_trace.default.trace("db.load", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({ db_name: this.name, num_args: args.length });
       return this.db.load(...args);
     });
   }
   createIndex(...args) {
     return import_dd_trace.default.trace("db.createIndex", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({ db_name: this.name, num_args: args.length });
       return this.db.createIndex(...args);
     });
   }
   deleteIndex(...args) {
     return import_dd_trace.default.trace("db.deleteIndex", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({ db_name: this.name, num_args: args.length });
       return this.db.deleteIndex(...args);
     });
   }
   getIndexes(...args) {
     return import_dd_trace.default.trace("db.getIndexes", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({ db_name: this.name, num_args: args.length });
       return this.db.getIndexes(...args);
     });
   }
   sql(sql, parameters) {
-    return import_dd_trace.default.trace("db.sql", (span) => {
-      span?.addTags({ db_name: this.name });
-      return this.db.sql(sql, parameters);
+    return import_dd_trace.default.trace("db.sql", async (span) => {
+      span.addTags({ db_name: this.name, num_bindings: parameters?.length });
+      const resp = await this.db.sql(sql, parameters);
+      span.addTags({ num_rows: resp.length });
+      return resp;
     });
   }
   sqlPurgeDocument(docIds) {
     return import_dd_trace.default.trace("db.sqlPurgeDocument", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({
+        db_name: this.name,
+        num_docs: Array.isArray(docIds) ? docIds.length : 1
+      });
       return this.db.sqlPurgeDocument(docIds);
     });
   }
   sqlDiskCleanup() {
     return import_dd_trace.default.trace("db.sqlDiskCleanup", (span) => {
-      span?.addTags({ db_name: this.name });
+      span.addTags({ db_name: this.name });
       return this.db.sqlDiskCleanup();
     });
   }
@@ -17563,7 +17608,7 @@ var DatabaseImpl = class _DatabaseImpl {
       return await this.nano().db.destroy(this.name);
     } catch (err) {
       if (err.statusCode === 404) {
-        return;
+        return { ok: true };
       } else {
         throw new CouchDBError(err.message, err);
       }
@@ -25624,7 +25669,7 @@ function isIgnoredType(type) {
   const ignored = ["link" /* LINK */, "formula" /* FORMULA */, "ai" /* AI */];
   return ignored.indexOf(type) !== -1;
 }
-function generateSchema(schema, table, tables, oldTable = null, renamed) {
+function generateSchema(schema, table, tables, oldTable, renamed) {
   let primaryKeys = table && table.primary ? table.primary : [];
   const columns = Object.values(table.schema);
   let metaCols = columns.filter((col) => col.meta);
@@ -25644,7 +25689,7 @@ function generateSchema(schema, table, tables, oldTable = null, renamed) {
     (col) => col.foreignKey
   );
   for (let [key, column] of Object.entries(table.schema)) {
-    const oldColumn = oldTable ? oldTable.schema[key] : null;
+    const oldColumn = oldTable?.schema[key];
     if (oldColumn && oldColumn.type || columnTypeSet.includes(key) || renamed?.updated === key) {
       continue;
     }
@@ -25784,16 +25829,15 @@ var SqlTableQueryBuilder = class {
    * @return the operation that was found in the JSON.
    */
   _operation(json) {
-    return json.endpoint.operation;
+    return json.operation;
   }
   _tableQuery(json) {
     let client = (0, import_knex.knex)({ client: this.sqlClient }).schema;
-    let schemaName = json?.endpoint?.schema;
-    if (schemaName) {
-      client = client.withSchema(schemaName);
+    if (json?.schema) {
+      client = client.withSchema(json.schema);
     }
     let query;
-    if (!json.table || !json.meta || !json.meta.tables) {
+    if (!json.table || !json.tables) {
       throw new Error("Cannot execute without table being specified");
     }
     if (json.table.sourceType === "internal" /* INTERNAL */) {
@@ -25801,15 +25845,15 @@ var SqlTableQueryBuilder = class {
     }
     switch (this._operation(json)) {
       case "CREATE_TABLE" /* CREATE_TABLE */:
-        query = buildCreateTable(client, json.table, json.meta.tables);
+        query = buildCreateTable(client, json.table, json.tables);
         break;
       case "UPDATE_TABLE" /* UPDATE_TABLE */:
-        if (!json.meta || !json.meta.table) {
+        if (!json.table) {
           throw new Error("Must specify old table for update");
         }
-        if (this.sqlClient === "mysql2" /* MY_SQL */ && json.meta.renamed) {
+        if (this.sqlClient === "mysql2" /* MY_SQL */ && json.meta?.renamed) {
           const updatedColumn = json.meta.renamed.updated;
-          const tableName = schemaName ? `\`${schemaName}\`.\`${json.table.name}\`` : `\`${json.table.name}\``;
+          const tableName = json?.schema ? `\`${json.schema}\`.\`${json.table.name}\`` : `\`${json.table.name}\``;
           return {
             sql: `alter table ${tableName} rename column \`${json.meta.renamed.old}\` to \`${updatedColumn}\`;`,
             bindings: []
@@ -25818,14 +25862,14 @@ var SqlTableQueryBuilder = class {
         query = buildUpdateTable(
           client,
           json.table,
-          json.meta.tables,
-          json.meta.table,
-          json.meta.renamed
+          json.tables,
+          json.meta?.oldTable,
+          json.meta?.renamed
         );
-        if (this.sqlClient === "mssql" /* MS_SQL */ && json.meta.renamed) {
+        if (this.sqlClient === "mssql" /* MS_SQL */ && json.meta?.renamed) {
           const oldColumn = json.meta.renamed.old;
           const updatedColumn = json.meta.renamed.updated;
-          const tableName = schemaName ? `${schemaName}.${json.table.name}` : `${json.table.name}`;
+          const tableName = json?.schema ? `${json.schema}.${json.table.name}` : `${json.table.name}`;
           const sql = getNativeSql(query);
           if (Array.isArray(sql)) {
             for (const query2 of sql) {
@@ -25936,11 +25980,11 @@ var InternalBuilder = class {
     this.knex = knex3;
     this.splitter = new filters_exports.ColumnSplitter([this.table], {
       aliases: this.query.tableAliases,
-      columnPrefix: this.query.meta.columnPrefix
+      columnPrefix: this.query.meta?.columnPrefix
     });
   }
   get table() {
-    return this.query.meta.table;
+    return this.query.table;
   }
   get knexClient() {
     return this.knex.client;
@@ -26029,8 +26073,7 @@ var InternalBuilder = class {
     return parts.join(".");
   }
   isFullSelectStatementRequired() {
-    const { meta } = this.query;
-    for (let column of Object.values(meta.table.schema)) {
+    for (let column of Object.values(this.table.schema)) {
       if (this.SPECIAL_SELECT_CASES.POSTGRES_MONEY(column)) {
         return true;
       } else if (this.SPECIAL_SELECT_CASES.MSSQL_DATES(column)) {
@@ -26040,29 +26083,29 @@ var InternalBuilder = class {
     return false;
   }
   generateSelectStatement() {
-    const { meta, endpoint, resource } = this.query;
+    const { table, resource } = this.query;
     if (!resource || !resource.fields || resource.fields.length === 0) {
       return "*";
     }
-    const alias = this.getTableName(endpoint.entityId);
-    const schema = meta.table.schema;
+    const alias = this.getTableName(table);
+    const schema = this.table.schema;
     if (!this.isFullSelectStatementRequired()) {
       return [this.knex.raw("??", [`${alias}.*`])];
     }
     return resource.fields.map((field) => {
       const parts = field.split(/\./g);
-      let table = void 0;
+      let table2 = void 0;
       let column = parts[0];
       if (parts.length > 1) {
-        table = parts[0];
+        table2 = parts[0];
         column = parts.slice(1).join(".");
       }
-      return { table, column, field };
-    }).filter(({ table }) => !table || table === alias).map(({ table, column, field }) => {
+      return { table: table2, column, field };
+    }).filter(({ table: table2 }) => !table2 || table2 === alias).map(({ table: table2, column, field }) => {
       const columnSchema = schema[column];
       if (this.SPECIAL_SELECT_CASES.POSTGRES_MONEY(columnSchema)) {
         return this.knex.raw(`??::money::numeric as ??`, [
-          this.rawQuotedIdentifier([table, column].join(".")),
+          this.rawQuotedIdentifier([table2, column].join(".")),
           this.knex.raw(this.quote(field))
         ]);
       }
@@ -26072,8 +26115,8 @@ var InternalBuilder = class {
           this.knex.raw(this.quote(field))
         ]);
       }
-      if (table) {
-        return this.rawQuotedIdentifier(`${table}.${column}`);
+      if (table2) {
+        return this.rawQuotedIdentifier(`${table2}.${column}`);
       } else {
         return this.rawQuotedIdentifier(field);
       }
@@ -26204,9 +26247,8 @@ var InternalBuilder = class {
     return query.andWhere(`${document}.fieldName`, "=", relationship.column);
   }
   addRelationshipForFilter(query, allowEmptyRelationships2, filterKey, whereCb) {
-    const { relationships, endpoint, tableAliases: aliases } = this.query;
-    const tableName = endpoint.entityId;
-    const fromAlias = aliases?.[tableName] || tableName;
+    const { relationships, schema, tableAliases: aliases, table } = this.query;
+    const fromAlias = aliases?.[table.name] || table.name;
     const matches2 = (value) => filterKey.match(new RegExp(`^${value}\\.`));
     if (!relationships) {
       return query;
@@ -26233,7 +26275,7 @@ var InternalBuilder = class {
           const throughAlias = aliases?.[manyToMany.through] || relationship.through;
           let throughTable = this.tableNameWithSchema(manyToMany.through, {
             alias: throughAlias,
-            schema: endpoint.schema
+            schema
           });
           subQuery = subQuery.innerJoin(throughTable, function() {
             this.on(
@@ -26614,22 +26656,8 @@ var InternalBuilder = class {
   isSqs() {
     return isSqs(this.table);
   }
-  getTableName(tableOrName) {
-    let table;
-    if (typeof tableOrName === "string") {
-      const name2 = tableOrName;
-      if (this.query.table?.name === name2) {
-        table = this.query.table;
-      } else if (this.query.meta.table?.name === name2) {
-        table = this.query.meta.table;
-      } else if (!this.query.meta.tables?.[name2]) {
-        return name2;
-      } else {
-        table = this.query.meta.tables[name2];
-      }
-    } else if (tableOrName) {
-      table = tableOrName;
-    } else {
+  getTableName(table) {
+    if (!table) {
       table = this.table;
     }
     let name = table.name;
@@ -26761,8 +26789,9 @@ var InternalBuilder = class {
     }
     return withSchema;
   }
-  buildJsonField(field) {
+  buildJsonField(table, field) {
     const parts = field.split(".");
+    let baseName = parts[parts.length - 1];
     let unaliased;
     let tableField;
     if (parts.length > 1) {
@@ -26773,8 +26802,15 @@ var InternalBuilder = class {
       unaliased = parts.join(".");
       tableField = unaliased;
     }
-    const separator = this.client === "oracledb" /* ORACLE */ ? " VALUE " : ",";
-    return this.knex.raw(`?${separator}??`, [unaliased, this.rawQuotedIdentifier(tableField)]).toString();
+    if (this.query.meta?.columnPrefix) {
+      baseName = baseName.replace(this.query.meta.columnPrefix, "");
+    }
+    let identifier = this.rawQuotedIdentifier(tableField);
+    const schema = table.schema[baseName];
+    if (schema && schema.type === "bigint" /* BIGINT */) {
+      identifier = this.castIntToString(identifier);
+    }
+    return [unaliased, identifier];
   }
   maxFunctionParameters() {
     switch (this.client) {
@@ -26789,7 +26825,7 @@ var InternalBuilder = class {
   addJsonRelationships(query, fromTable, relationships) {
     const sqlClient = this.client;
     const knex3 = this.knex;
-    const { resource, tableAliases: aliases, endpoint, meta } = this.query;
+    const { resource, tableAliases: aliases, schema, tables } = this.query;
     const fields = resource?.fields || [];
     for (let relationship of relationships) {
       const {
@@ -26803,11 +26839,14 @@ var InternalBuilder = class {
       if (!toTable || !fromTable) {
         continue;
       }
-      const relatedTable = meta.tables?.[toTable];
+      const relatedTable = tables[toTable];
+      if (!relatedTable) {
+        throw new Error(`related table "${toTable}" not found in datasource`);
+      }
       const toAlias = aliases?.[toTable] || toTable, fromAlias = aliases?.[fromTable] || fromTable, throughAlias = throughTable && aliases?.[throughTable] || throughTable;
       let toTableWithSchema = this.tableNameWithSchema(toTable, {
         alias: toAlias,
-        schema: endpoint.schema
+        schema
       });
       const requiredFields = [
         ...relatedTable?.primary || [],
@@ -26821,7 +26860,13 @@ var InternalBuilder = class {
         0,
         Math.floor(this.maxFunctionParameters() / 2)
       );
-      const fieldList = relationshipFields.map((field) => this.buildJsonField(field)).join(",");
+      const fieldList = relationshipFields.map(
+        (field) => this.buildJsonField(relatedTable, field)
+      );
+      const fieldListFormatted = fieldList.map((f) => {
+        const separator = this.client === "oracledb" /* ORACLE */ ? " VALUE " : ",";
+        return this.knex.raw(`?${separator}??`, [f[0], f[1]]).toString();
+      }).join(",");
       const primaryKey = `${toAlias}.${toPrimary || toKey}`;
       let subQuery = knex3.from(toTableWithSchema).orderBy(primaryKey);
       const isManyToMany = throughTable && toPrimary && fromPrimary;
@@ -26829,7 +26874,7 @@ var InternalBuilder = class {
       if (isManyToMany) {
         let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
           alias: throughAlias,
-          schema: endpoint.schema
+          schema
         });
         subQuery = subQuery.join(throughTableWithSchema, function() {
           this.on(`${toAlias}.${toPrimary}`, "=", `${throughAlias}.${toKey}`);
@@ -26851,30 +26896,36 @@ var InternalBuilder = class {
         case "sqlite3" /* SQL_LITE */:
           subQuery = this.addJoinFieldCheck(subQuery, relationship);
           wrapperQuery = standardWrap(
-            this.knex.raw(`json_group_array(json_object(${fieldList}))`)
+            this.knex.raw(
+              `json_group_array(json_object(${fieldListFormatted}))`
+            )
           );
           break;
         case "pg" /* POSTGRES */:
           wrapperQuery = standardWrap(
-            this.knex.raw(`json_agg(json_build_object(${fieldList}))`)
+            this.knex.raw(`json_agg(json_build_object(${fieldListFormatted}))`)
           );
           break;
         case "mariadb" /* MARIADB */:
           wrapperQuery = subQuery.select(
             knex3.raw(
-              `json_arrayagg(json_object(${fieldList}) LIMIT ${getRelationshipLimit()})`
+              `json_arrayagg(json_object(${fieldListFormatted}) LIMIT ${getRelationshipLimit()})`
             )
           );
           break;
         case "mysql2" /* MY_SQL */:
         case "oracledb" /* ORACLE */:
           wrapperQuery = standardWrap(
-            this.knex.raw(`json_arrayagg(json_object(${fieldList}))`)
+            this.knex.raw(`json_arrayagg(json_object(${fieldListFormatted}))`)
           );
           break;
         case "mssql" /* MS_SQL */: {
-          const comparatorQuery = knex3.select(`${fromAlias}.*`).from({
-            [fromAlias]: subQuery.select(`${toAlias}.*`).limit(getRelationshipLimit())
+          const comparatorQuery = knex3.select(`*`).from({
+            [fromAlias]: subQuery.select(
+              fieldList.map((f) => {
+                return knex3.ref(f[1]).as(f[0]);
+              })
+            ).limit(getRelationshipLimit())
           });
           wrapperQuery = knex3.raw(
             `(SELECT ?? = (${comparatorQuery} FOR JSON PATH))`,
@@ -26890,8 +26941,7 @@ var InternalBuilder = class {
     return query;
   }
   addJoin(query, tables, columns) {
-    const { tableAliases: aliases, endpoint } = this.query;
-    const schema = endpoint.schema;
+    const { tableAliases: aliases, schema } = this.query;
     const toTable = tables.to, fromTable = tables.from, throughTable = tables.through;
     const toAlias = aliases?.[toTable] || toTable, throughAlias = throughTable && aliases?.[throughTable] || throughTable, fromAlias = aliases?.[fromTable] || fromTable;
     let toTableWithSchema = this.tableNameWithSchema(toTable, {
@@ -26931,16 +26981,16 @@ var InternalBuilder = class {
     return query;
   }
   qualifiedKnex(opts) {
-    let alias = this.query.tableAliases?.[this.query.endpoint.entityId];
+    let alias = this.query.tableAliases?.[this.query.table.name];
     if (opts?.alias === false) {
       alias = void 0;
     } else if (typeof opts?.alias === "string") {
       alias = opts.alias;
     }
     return this.knex(
-      this.tableNameWithSchema(this.query.endpoint.entityId, {
+      this.tableNameWithSchema(this.query.table.name, {
         alias,
-        schema: this.query.endpoint.schema
+        schema: this.query.schema
       })
     );
   }
@@ -26952,9 +27002,7 @@ var InternalBuilder = class {
     let query = this.qualifiedKnex({ alias: false });
     const parsedBody = this.parseBody(body2);
     if (this.client === "oracledb" /* ORACLE */) {
-      for (const [column, schema] of Object.entries(
-        this.query.meta.table.schema
-      )) {
+      for (const [column, schema] of Object.entries(this.query.table.schema)) {
         if (schema.constraints?.presence === true || schema.type === "formula" /* FORMULA */ || schema.type === "auto" /* AUTO */ || schema.type === "link" /* LINK */ || schema.type === "ai" /* AI */) {
           continue;
         }
@@ -27004,10 +27052,8 @@ var InternalBuilder = class {
     return query.upsert(parsedBody);
   }
   read(opts = {}) {
-    let { endpoint, filters, paginate, relationships } = this.query;
+    let { operation, filters, paginate, relationships, table } = this.query;
     const { limits } = opts;
-    const counting = endpoint.operation === "COUNT" /* COUNT */;
-    const tableName = endpoint.entityId;
     let query = this.qualifiedKnex();
     let foundOffset = null;
     let foundLimit = limits?.query || limits?.base;
@@ -27022,7 +27068,7 @@ var InternalBuilder = class {
     } else if (paginate && paginate.limit) {
       foundLimit = paginate.limit;
     }
-    if (!counting) {
+    if (operation !== "COUNT" /* COUNT */) {
       if (foundLimit != null) {
         query = query.limit(foundLimit);
       }
@@ -27031,25 +27077,25 @@ var InternalBuilder = class {
       }
     }
     const aggregations = this.query.resource?.aggregations || [];
-    if (counting) {
+    if (operation === "COUNT" /* COUNT */) {
       query = this.addDistinctCount(query);
     } else if (aggregations.length > 0) {
       query = this.addAggregations(query, aggregations);
     } else {
       query = query.select(this.generateSelectStatement());
     }
-    if (!counting) {
+    if (operation !== "COUNT" /* COUNT */) {
       query = this.addSorting(query);
     }
     query = this.addFilters(query, filters, { relationship: true });
     if (relationships?.length && aggregations.length === 0) {
-      const mainTable = this.query.tableAliases?.[this.query.endpoint.entityId] || this.query.endpoint.entityId;
+      const mainTable = this.query.tableAliases?.[table.name] || table.name;
       const cte = this.addSorting(
         this.knex.with("paginated", query).select(this.generateSelectStatement()).from({
           [mainTable]: "paginated"
         })
       );
-      return this.addJsonRelationships(cte, tableName, relationships);
+      return this.addJsonRelationships(cte, table.name, relationships);
     }
     return query;
   }
@@ -27154,28 +27200,24 @@ var SqlQueryBuilder = class extends sqlTable_default {
       return {};
     }
     const input = this._query({
-      endpoint: {
-        ...json.endpoint,
-        operation: "READ" /* READ */
-      },
-      resource: {
-        fields: []
-      },
+      operation: "READ" /* READ */,
+      datasource: json.datasource,
+      schema: json.schema,
+      table: json.table,
+      tables: json.tables,
+      resource: { fields: [] },
       filters: json.extra?.idFilter,
-      paginate: {
-        limit: 1
-      },
-      meta: json.meta
+      paginate: { limit: 1 }
     });
     return queryFn(input, "READ" /* READ */);
   }
   // when creating if an ID has been inserted need to make sure
   // the id filter is enriched with it before trying to retrieve the row
   checkLookupKeys(id, json) {
-    if (!id || !json.meta.table || !json.meta.table.primary) {
+    if (!id || !json.table.primary) {
       return json;
     }
-    const primaryKey = json.meta.table.primary?.[0];
+    const primaryKey = json.table.primary[0];
     json.extra = {
       idFilter: {
         equal: {