diff --git a/lerna.json b/lerna.json
index 3a92bc6d9a..ec64523dff 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
{
- "version": "2.22.7",
+ "version": "2.22.8",
"npmClient": "yarn",
"packages": [
"packages/*",
diff --git a/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte b/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
index c2cda1f2d8..f2c726c8bf 100644
--- a/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
+++ b/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
@@ -28,7 +28,6 @@
let deleteTableName
$: externalTable = table?.sourceType === DB_TYPE_EXTERNAL
- $: allowDeletion = !externalTable || table?.created
function showDeleteModal() {
templateScreens = $screenStore.screens.filter(
@@ -56,7 +55,7 @@
$goto(`./datasource/${table.datasourceId}`)
}
} catch (error) {
- notifications.error("Error deleting table")
+ notifications.error(`Error deleting table - ${error.message}`)
}
}
@@ -86,17 +85,15 @@
}
-{#if allowDeletion}
-
-
-
-
- {#if !externalTable}
-
- {/if}
-
-
-{/if}
+
+
+
+
+ {#if !externalTable}
+
+ {/if}
+
+
import { getContext } from "svelte"
+ import { get } from "svelte/store"
import { generate } from "shortid"
import Block from "components/Block.svelte"
import BlockComponent from "components/BlockComponent.svelte"
@@ -33,8 +34,9 @@
export let sidePanelDeleteLabel
export let notificationOverride
- const { fetchDatasourceSchema, API } = getContext("sdk")
+ const { fetchDatasourceSchema, API, generateGoldenSample } = getContext("sdk")
const component = getContext("component")
+ const context = getContext("context")
const stateKey = `ID_${generate()}`
let formId
@@ -48,20 +50,6 @@
let schemaLoaded = false
$: deleteLabel = setDeleteLabel(sidePanelDeleteLabel, sidePanelShowDelete)
-
- const setDeleteLabel = sidePanelDeleteLabel => {
- // Accommodate old config to ensure delete button does not reappear
- let labelText = sidePanelShowDelete === false ? "" : sidePanelDeleteLabel
-
- // Empty text is considered hidden.
- if (labelText?.trim() === "") {
- return ""
- }
-
- // Default to "Delete" if the value is unset
- return labelText || "Delete"
- }
-
$: isDSPlus = dataSource?.type === "table" || dataSource?.type === "viewV2"
$: fetchSchema(dataSource)
$: enrichSearchColumns(searchColumns, schema).then(
@@ -105,6 +93,30 @@
},
]
+ // Provide additional data context for live binding eval
+ export const getAdditionalDataContext = () => {
+ const rows = get(context)[dataProviderId]?.rows
+ const goldenRow = generateGoldenSample(rows)
+ return {
+ eventContext: {
+ row: goldenRow,
+ },
+ }
+ }
+
+ const setDeleteLabel = sidePanelDeleteLabel => {
+ // Accommodate old config to ensure delete button does not reappear
+ let labelText = sidePanelShowDelete === false ? "" : sidePanelDeleteLabel
+
+ // Empty text is considered hidden.
+ if (labelText?.trim() === "") {
+ return ""
+ }
+
+ // Default to "Delete" if the value is unset
+ return labelText || "Delete"
+ }
+
// Load the datasource schema so we can determine column types
const fetchSchema = async dataSource => {
if (dataSource?.type === "table") {
diff --git a/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte b/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
index 5e3a035d89..ed09301bb9 100644
--- a/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
+++ b/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
@@ -40,16 +40,18 @@
}
}
+ // Handle certain key presses regardless of selection state
+ if (e.key === "Enter" && (e.ctrlKey || e.metaKey) && $config.canAddRows) {
+ e.preventDefault()
+ dispatch("add-row-inline")
+ return
+ }
+
// If nothing selected avoid processing further key presses
if (!$focusedCellId) {
if (e.key === "Tab" || e.key?.startsWith("Arrow")) {
e.preventDefault()
focusFirstCell()
- } else if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
- if ($config.canAddRows) {
- e.preventDefault()
- dispatch("add-row-inline")
- }
} else if (e.key === "Delete" || e.key === "Backspace") {
if (Object.keys($selectedRows).length && $config.canDeleteRows) {
dispatch("request-bulk-delete")
diff --git a/packages/server/__mocks__/mssql.ts b/packages/server/__mocks__/mssql.ts
deleted file mode 100644
index 6a34e1e9d7..0000000000
--- a/packages/server/__mocks__/mssql.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-module.exports = {
- ConnectionPool: jest.fn(() => ({
- connect: jest.fn(() => ({
- request: jest.fn(() => ({
- query: jest.fn(sql => ({ recordset: [sql] })),
- })),
- })),
- })),
- query: jest.fn(() => ({
- recordset: [
- {
- a: "string",
- b: 1,
- },
- ],
- })),
-}
diff --git a/packages/server/__mocks__/mysql2.ts b/packages/server/__mocks__/mysql2.ts
deleted file mode 100644
index 67ff897811..0000000000
--- a/packages/server/__mocks__/mysql2.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-const client = {
- connect: jest.fn(),
- query: jest.fn((query, bindings, fn) => {
- fn(null, [])
- }),
-}
-
-module.exports = {
- createConnection: jest.fn(() => client),
- client,
-}
diff --git a/packages/server/__mocks__/mysql2/promise.ts b/packages/server/__mocks__/mysql2/promise.ts
deleted file mode 100644
index f8a4c7b2d6..0000000000
--- a/packages/server/__mocks__/mysql2/promise.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-module MySQLMock {
- const mysql: any = {}
-
- const client = {
- connect: jest.fn(),
- end: jest.fn(),
- query: jest.fn(async () => {
- return [[]]
- }),
- }
-
- mysql.createConnection = jest.fn(async () => {
- return client
- })
-
- module.exports = mysql
-}
diff --git a/packages/server/src/api/controllers/table/external.ts b/packages/server/src/api/controllers/table/external.ts
index c85b46a95c..7c036bec9d 100644
--- a/packages/server/src/api/controllers/table/external.ts
+++ b/packages/server/src/api/controllers/table/external.ts
@@ -61,9 +61,6 @@ export async function destroy(ctx: UserCtx) {
const tableToDelete: TableRequest = await sdk.tables.getTable(
ctx.params.tableId
)
- if (!tableToDelete || !tableToDelete.created) {
- ctx.throw(400, "Cannot delete tables which weren't created in Budibase.")
- }
const datasourceId = getDatasourceId(tableToDelete)
try {
const { datasource, table } = await sdk.tables.external.destroy(
diff --git a/packages/server/src/api/routes/tests/debug.spec.ts b/packages/server/src/api/routes/tests/debug.spec.ts
index 53e1f67823..546344a646 100644
--- a/packages/server/src/api/routes/tests/debug.spec.ts
+++ b/packages/server/src/api/routes/tests/debug.spec.ts
@@ -1,13 +1,5 @@
-const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
-const setup = require("./utilities")
-
-import os from "os"
-
-jest.mock("process", () => ({
- arch: "arm64",
- version: "v14.20.1",
- platform: "darwin",
-}))
+import * as setup from "./utilities"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
describe("/component", () => {
let request = setup.getRequest()
@@ -17,21 +9,6 @@ describe("/component", () => {
beforeAll(async () => {
await config.init()
- os.cpus = () => [
- {
- model: "test",
- speed: 12323,
- times: {
- user: 0,
- nice: 0,
- sys: 0,
- idle: 0,
- irq: 0,
- },
- },
- ]
- os.uptime = () => 123123123123
- os.totalmem = () => 10000000000
})
describe("/api/debug", () => {
@@ -43,14 +20,16 @@ describe("/component", () => {
.expect(200)
expect(res.body).toEqual({
budibaseVersion: "0.0.0+jest",
- cpuArch: "arm64",
- cpuCores: 1,
- cpuInfo: "test",
+ cpuArch: expect.any(String),
+ cpuCores: expect.any(Number),
+ cpuInfo: expect.any(String),
hosting: "docker-compose",
- nodeVersion: "v14.20.1",
- platform: "darwin",
- totalMemory: "9.313225746154785GB",
- uptime: "1425036 day(s), 3 hour(s), 32 minute(s)",
+ nodeVersion: expect.stringMatching(/^v\d+\.\d+\.\d+$/),
+ platform: expect.any(String),
+ totalMemory: expect.stringMatching(/^[0-9\\.]+GB$/),
+ uptime: expect.stringMatching(
+ /^\d+ day\(s\), \d+ hour\(s\), \d+ minute\(s\)$/
+ ),
})
})
diff --git a/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts b/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts
new file mode 100644
index 0000000000..1fc0ecb382
--- /dev/null
+++ b/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts
@@ -0,0 +1,401 @@
+import { Datasource, Query, SourceName } from "@budibase/types"
+import * as setup from "../utilities"
+import { databaseTestProviders } from "../../../../integrations/tests/utils"
+import pg from "pg"
+import mysql from "mysql2/promise"
+import mssql from "mssql"
+
+jest.unmock("pg")
+
+const createTableSQL: Record = {
+ [SourceName.POSTGRES]: `
+ CREATE TABLE test_table (
+ id serial PRIMARY KEY,
+ name VARCHAR ( 50 ) NOT NULL,
+ birthday TIMESTAMP
+ );`,
+ [SourceName.MYSQL]: `
+ CREATE TABLE test_table (
+ id INT AUTO_INCREMENT PRIMARY KEY,
+ name VARCHAR(50) NOT NULL,
+ birthday TIMESTAMP
+ );`,
+ [SourceName.SQL_SERVER]: `
+ CREATE TABLE test_table (
+ id INT IDENTITY(1,1) PRIMARY KEY,
+ name NVARCHAR(50) NOT NULL,
+ birthday DATETIME
+ );`,
+}
+
+const insertSQL = `INSERT INTO test_table (name) VALUES ('one'), ('two'), ('three'), ('four'), ('five')`
+const dropTableSQL = `DROP TABLE test_table;`
+
+describe.each([
+ ["postgres", databaseTestProviders.postgres],
+ ["mysql", databaseTestProviders.mysql],
+ ["mssql", databaseTestProviders.mssql],
+ ["mariadb", databaseTestProviders.mariadb],
+])("queries (%s)", (__, dsProvider) => {
+ const config = setup.getConfig()
+ let datasource: Datasource
+
+ async function createQuery(query: Partial): Promise {
+ const defaultQuery: Query = {
+ datasourceId: datasource._id!,
+ name: "New Query",
+ parameters: [],
+ fields: {},
+ schema: {},
+ queryVerb: "read",
+ transformer: "return data",
+ readable: true,
+ }
+ return await config.api.query.create({ ...defaultQuery, ...query })
+ }
+
+ async function rawQuery(sql: string): Promise {
+ // We re-fetch the datasource here because the one returned by
+ // config.api.datasource.create has the password field blanked out, and we
+ // need the password to connect to the database.
+ const ds = await dsProvider.datasource()
+ switch (ds.source) {
+ case SourceName.POSTGRES: {
+ const client = new pg.Client(ds.config!)
+ await client.connect()
+ try {
+ const { rows } = await client.query(sql)
+ return rows
+ } finally {
+ await client.end()
+ }
+ }
+ case SourceName.MYSQL: {
+ const con = await mysql.createConnection(ds.config!)
+ try {
+ const [rows] = await con.query(sql)
+ return rows
+ } finally {
+ con.end()
+ }
+ }
+ case SourceName.SQL_SERVER: {
+ const pool = new mssql.ConnectionPool(ds.config! as mssql.config)
+ const client = await pool.connect()
+ try {
+ const { recordset } = await client.query(sql)
+ return recordset
+ } finally {
+ await pool.close()
+ }
+ }
+ }
+ }
+
+ beforeAll(async () => {
+ await config.init()
+ datasource = await config.api.datasource.create(
+ await dsProvider.datasource()
+ )
+ })
+
+ beforeEach(async () => {
+ await rawQuery(createTableSQL[datasource.source])
+ await rawQuery(insertSQL)
+ })
+
+ afterEach(async () => {
+ await rawQuery(dropTableSQL)
+ })
+
+ afterAll(async () => {
+ await dsProvider.stop()
+ setup.afterAll()
+ })
+
+ describe("create", () => {
+ it("should be able to insert with bindings", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
+ },
+ parameters: [
+ {
+ name: "foo",
+ default: "bar",
+ },
+ ],
+ queryVerb: "create",
+ })
+
+ const result = await config.api.query.execute(query._id!, {
+ parameters: {
+ foo: "baz",
+ },
+ })
+
+ expect(result.data).toEqual([
+ {
+ created: true,
+ },
+ ])
+
+ const rows = await rawQuery("SELECT * FROM test_table WHERE name = 'baz'")
+ expect(rows).toHaveLength(1)
+ })
+
+ it.each(["2021-02-05T12:01:00.000Z", "2021-02-05"])(
+ "should coerce %s into a date",
+ async datetimeStr => {
+ const date = new Date(datetimeStr)
+ const query = await createQuery({
+ fields: {
+ sql: `INSERT INTO test_table (name, birthday) VALUES ('foo', {{ birthday }})`,
+ },
+ parameters: [
+ {
+ name: "birthday",
+ default: "",
+ },
+ ],
+ queryVerb: "create",
+ })
+
+ const result = await config.api.query.execute(query._id!, {
+ parameters: { birthday: datetimeStr },
+ })
+
+ expect(result.data).toEqual([{ created: true }])
+
+ const rows = await rawQuery(
+ `SELECT * FROM test_table WHERE birthday = '${date.toISOString()}'`
+ )
+ expect(rows).toHaveLength(1)
+ }
+ )
+
+ it.each(["2021,02,05", "202205-1500"])(
+ "should not coerce %s as a date",
+ async notDateStr => {
+ const query = await createQuery({
+ fields: {
+ sql: "INSERT INTO test_table (name) VALUES ({{ name }})",
+ },
+ parameters: [
+ {
+ name: "name",
+ default: "",
+ },
+ ],
+ queryVerb: "create",
+ })
+
+ const result = await config.api.query.execute(query._id!, {
+ parameters: {
+ name: notDateStr,
+ },
+ })
+
+ expect(result.data).toEqual([{ created: true }])
+
+ const rows = await rawQuery(
+ `SELECT * FROM test_table WHERE name = '${notDateStr}'`
+ )
+ expect(rows).toHaveLength(1)
+ }
+ )
+ })
+
+ describe("read", () => {
+ it("should execute a query", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "SELECT * FROM test_table ORDER BY id",
+ },
+ })
+
+ const result = await config.api.query.execute(query._id!)
+
+ expect(result.data).toEqual([
+ {
+ id: 1,
+ name: "one",
+ birthday: null,
+ },
+ {
+ id: 2,
+ name: "two",
+ birthday: null,
+ },
+ {
+ id: 3,
+ name: "three",
+ birthday: null,
+ },
+ {
+ id: 4,
+ name: "four",
+ birthday: null,
+ },
+ {
+ id: 5,
+ name: "five",
+ birthday: null,
+ },
+ ])
+ })
+
+ it("should be able to transform a query", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "SELECT * FROM test_table WHERE id = 1",
+ },
+ transformer: `
+ data[0].id = data[0].id + 1;
+ return data;
+ `,
+ })
+
+ const result = await config.api.query.execute(query._id!)
+
+ expect(result.data).toEqual([
+ {
+ id: 2,
+ name: "one",
+ birthday: null,
+ },
+ ])
+ })
+
+ it("should coerce numeric bindings", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "SELECT * FROM test_table WHERE id = {{ id }}",
+ },
+ parameters: [
+ {
+ name: "id",
+ default: "",
+ },
+ ],
+ })
+
+ const result = await config.api.query.execute(query._id!, {
+ parameters: {
+ id: "1",
+ },
+ })
+
+ expect(result.data).toEqual([
+ {
+ id: 1,
+ name: "one",
+ birthday: null,
+ },
+ ])
+ })
+ })
+
+ describe("update", () => {
+ it("should be able to update rows", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}",
+ },
+ parameters: [
+ {
+ name: "id",
+ default: "",
+ },
+ {
+ name: "name",
+ default: "updated",
+ },
+ ],
+ queryVerb: "update",
+ })
+
+ const result = await config.api.query.execute(query._id!, {
+ parameters: {
+ id: "1",
+ name: "foo",
+ },
+ })
+
+ expect(result.data).toEqual([
+ {
+ updated: true,
+ },
+ ])
+
+ const rows = await rawQuery("SELECT * FROM test_table WHERE id = 1")
+ expect(rows).toEqual([{ id: 1, name: "foo", birthday: null }])
+ })
+
+ it("should be able to execute an update that updates no rows", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "UPDATE test_table SET name = 'updated' WHERE id = 100",
+ },
+ queryVerb: "update",
+ })
+
+ const result = await config.api.query.execute(query._id!)
+
+ expect(result.data).toEqual([
+ {
+ updated: true,
+ },
+ ])
+ })
+
+ it("should be able to execute a delete that deletes no rows", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "DELETE FROM test_table WHERE id = 100",
+ },
+ queryVerb: "delete",
+ })
+
+ const result = await config.api.query.execute(query._id!)
+
+ expect(result.data).toEqual([
+ {
+ deleted: true,
+ },
+ ])
+ })
+ })
+
+ describe("delete", () => {
+ it("should be able to delete rows", async () => {
+ const query = await createQuery({
+ fields: {
+ sql: "DELETE FROM test_table WHERE id = {{ id }}",
+ },
+ parameters: [
+ {
+ name: "id",
+ default: "",
+ },
+ ],
+ queryVerb: "delete",
+ })
+
+ const result = await config.api.query.execute(query._id!, {
+ parameters: {
+ id: "1",
+ },
+ })
+
+ expect(result.data).toEqual([
+ {
+ deleted: true,
+ },
+ ])
+
+ const rows = await rawQuery("SELECT * FROM test_table WHERE id = 1")
+ expect(rows).toHaveLength(0)
+ })
+ })
+})
diff --git a/packages/server/src/api/routes/tests/queries/mysql.spec.ts b/packages/server/src/api/routes/tests/queries/mysql.spec.ts
deleted file mode 100644
index 6c97ab5835..0000000000
--- a/packages/server/src/api/routes/tests/queries/mysql.spec.ts
+++ /dev/null
@@ -1,239 +0,0 @@
-import { Datasource, Query } from "@budibase/types"
-import * as setup from "../utilities"
-import { databaseTestProviders } from "../../../../integrations/tests/utils"
-import mysql from "mysql2/promise"
-
-jest.unmock("mysql2")
-jest.unmock("mysql2/promise")
-
-const createTableSQL = `
-CREATE TABLE test_table (
- id INT AUTO_INCREMENT PRIMARY KEY,
- name VARCHAR(50) NOT NULL
-)
-`
-
-const insertSQL = `
-INSERT INTO test_table (name) VALUES ('one'), ('two'), ('three'), ('four'), ('five')
-`
-
-const dropTableSQL = `
-DROP TABLE test_table
-`
-
-describe("/queries", () => {
- let config = setup.getConfig()
- let datasource: Datasource
-
- async function createQuery(query: Partial): Promise {
- const defaultQuery: Query = {
- datasourceId: datasource._id!,
- name: "New Query",
- parameters: [],
- fields: {},
- schema: {},
- queryVerb: "read",
- transformer: "return data",
- readable: true,
- }
- return await config.api.query.create({ ...defaultQuery, ...query })
- }
-
- async function withConnection(
- callback: (client: mysql.Connection) => Promise
- ): Promise {
- const ds = await databaseTestProviders.mysql.datasource()
- const con = await mysql.createConnection(ds.config!)
- try {
- await callback(con)
- } finally {
- con.end()
- }
- }
-
- afterAll(async () => {
- await databaseTestProviders.mysql.stop()
- setup.afterAll()
- })
-
- beforeAll(async () => {
- await config.init()
- datasource = await config.api.datasource.create(
- await databaseTestProviders.mysql.datasource()
- )
- })
-
- beforeEach(async () => {
- await withConnection(async connection => {
- await connection.query(createTableSQL)
- await connection.query(insertSQL)
- })
- })
-
- afterEach(async () => {
- await withConnection(async connection => {
- await connection.query(dropTableSQL)
- })
- })
-
- it("should execute a query", async () => {
- const query = await createQuery({
- fields: {
- sql: "SELECT * FROM test_table ORDER BY id",
- },
- })
-
- const result = await config.api.query.execute(query._id!)
-
- expect(result.data).toEqual([
- {
- id: 1,
- name: "one",
- },
- {
- id: 2,
- name: "two",
- },
- {
- id: 3,
- name: "three",
- },
- {
- id: 4,
- name: "four",
- },
- {
- id: 5,
- name: "five",
- },
- ])
- })
-
- it("should be able to transform a query", async () => {
- const query = await createQuery({
- fields: {
- sql: "SELECT * FROM test_table WHERE id = 1",
- },
- transformer: `
- data[0].id = data[0].id + 1;
- return data;
- `,
- })
-
- const result = await config.api.query.execute(query._id!)
-
- expect(result.data).toEqual([
- {
- id: 2,
- name: "one",
- },
- ])
- })
-
- it("should be able to insert with bindings", async () => {
- const query = await createQuery({
- fields: {
- sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
- },
- parameters: [
- {
- name: "foo",
- default: "bar",
- },
- ],
- queryVerb: "create",
- })
-
- const result = await config.api.query.execute(query._id!, {
- parameters: {
- foo: "baz",
- },
- })
-
- expect(result.data).toEqual([
- {
- created: true,
- },
- ])
-
- await withConnection(async connection => {
- const [rows] = await connection.query(
- "SELECT * FROM test_table WHERE name = 'baz'"
- )
- expect(rows).toHaveLength(1)
- })
- })
-
- it("should be able to update rows", async () => {
- const query = await createQuery({
- fields: {
- sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}",
- },
- parameters: [
- {
- name: "id",
- default: "",
- },
- {
- name: "name",
- default: "updated",
- },
- ],
- queryVerb: "update",
- })
-
- const result = await config.api.query.execute(query._id!, {
- parameters: {
- id: "1",
- name: "foo",
- },
- })
-
- expect(result.data).toEqual([
- {
- updated: true,
- },
- ])
-
- await withConnection(async connection => {
- const [rows] = await connection.query(
- "SELECT * FROM test_table WHERE id = 1"
- )
- expect(rows).toEqual([{ id: 1, name: "foo" }])
- })
- })
-
- it("should be able to delete rows", async () => {
- const query = await createQuery({
- fields: {
- sql: "DELETE FROM test_table WHERE id = {{ id }}",
- },
- parameters: [
- {
- name: "id",
- default: "",
- },
- ],
- queryVerb: "delete",
- })
-
- const result = await config.api.query.execute(query._id!, {
- parameters: {
- id: "1",
- },
- })
-
- expect(result.data).toEqual([
- {
- deleted: true,
- },
- ])
-
- await withConnection(async connection => {
- const [rows] = await connection.query(
- "SELECT * FROM test_table WHERE id = 1"
- )
- expect(rows).toHaveLength(0)
- })
- })
-})
diff --git a/packages/server/src/api/routes/tests/queries/postgres.spec.ts b/packages/server/src/api/routes/tests/queries/postgres.spec.ts
deleted file mode 100644
index fd6a2b7d3c..0000000000
--- a/packages/server/src/api/routes/tests/queries/postgres.spec.ts
+++ /dev/null
@@ -1,243 +0,0 @@
-import { Datasource, Query } from "@budibase/types"
-import * as setup from "../utilities"
-import { databaseTestProviders } from "../../../../integrations/tests/utils"
-import { Client } from "pg"
-
-jest.unmock("pg")
-
-const createTableSQL = `
-CREATE TABLE test_table (
- id serial PRIMARY KEY,
- name VARCHAR ( 50 ) NOT NULL
-);
-`
-
-const insertSQL = `
-INSERT INTO test_table (name) VALUES ('one');
-INSERT INTO test_table (name) VALUES ('two');
-INSERT INTO test_table (name) VALUES ('three');
-INSERT INTO test_table (name) VALUES ('four');
-INSERT INTO test_table (name) VALUES ('five');
-`
-
-const dropTableSQL = `
-DROP TABLE test_table;
-`
-
-describe("/queries", () => {
- let config = setup.getConfig()
- let datasource: Datasource
-
- async function createQuery(query: Partial): Promise {
- const defaultQuery: Query = {
- datasourceId: datasource._id!,
- name: "New Query",
- parameters: [],
- fields: {},
- schema: {},
- queryVerb: "read",
- transformer: "return data",
- readable: true,
- }
- return await config.api.query.create({ ...defaultQuery, ...query })
- }
-
- async function withClient(
- callback: (client: Client) => Promise
- ): Promise {
- const ds = await databaseTestProviders.postgres.datasource()
- const client = new Client(ds.config!)
- await client.connect()
- try {
- await callback(client)
- } finally {
- await client.end()
- }
- }
-
- afterAll(async () => {
- await databaseTestProviders.postgres.stop()
- setup.afterAll()
- })
-
- beforeAll(async () => {
- await config.init()
- datasource = await config.api.datasource.create(
- await databaseTestProviders.postgres.datasource()
- )
- })
-
- beforeEach(async () => {
- await withClient(async client => {
- await client.query(createTableSQL)
- await client.query(insertSQL)
- })
- })
-
- afterEach(async () => {
- await withClient(async client => {
- await client.query(dropTableSQL)
- })
- })
-
- it("should execute a query", async () => {
- const query = await createQuery({
- fields: {
- sql: "SELECT * FROM test_table ORDER BY id",
- },
- })
-
- const result = await config.api.query.execute(query._id!)
-
- expect(result.data).toEqual([
- {
- id: 1,
- name: "one",
- },
- {
- id: 2,
- name: "two",
- },
- {
- id: 3,
- name: "three",
- },
- {
- id: 4,
- name: "four",
- },
- {
- id: 5,
- name: "five",
- },
- ])
- })
-
- it("should be able to transform a query", async () => {
- const query = await createQuery({
- fields: {
- sql: "SELECT * FROM test_table WHERE id = 1",
- },
- transformer: `
- data[0].id = data[0].id + 1;
- return data;
- `,
- })
-
- const result = await config.api.query.execute(query._id!)
-
- expect(result.data).toEqual([
- {
- id: 2,
- name: "one",
- },
- ])
- })
-
- it("should be able to insert with bindings", async () => {
- const query = await createQuery({
- fields: {
- sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
- },
- parameters: [
- {
- name: "foo",
- default: "bar",
- },
- ],
- queryVerb: "create",
- })
-
- const result = await config.api.query.execute(query._id!, {
- parameters: {
- foo: "baz",
- },
- })
-
- expect(result.data).toEqual([
- {
- created: true,
- },
- ])
-
- await withClient(async client => {
- const { rows } = await client.query(
- "SELECT * FROM test_table WHERE name = 'baz'"
- )
- expect(rows).toHaveLength(1)
- })
- })
-
- it("should be able to update rows", async () => {
- const query = await createQuery({
- fields: {
- sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}",
- },
- parameters: [
- {
- name: "id",
- default: "",
- },
- {
- name: "name",
- default: "updated",
- },
- ],
- queryVerb: "update",
- })
-
- const result = await config.api.query.execute(query._id!, {
- parameters: {
- id: "1",
- name: "foo",
- },
- })
-
- expect(result.data).toEqual([
- {
- updated: true,
- },
- ])
-
- await withClient(async client => {
- const { rows } = await client.query(
- "SELECT * FROM test_table WHERE id = 1"
- )
- expect(rows).toEqual([{ id: 1, name: "foo" }])
- })
- })
-
- it("should be able to delete rows", async () => {
- const query = await createQuery({
- fields: {
- sql: "DELETE FROM test_table WHERE id = {{ id }}",
- },
- parameters: [
- {
- name: "id",
- default: "",
- },
- ],
- queryVerb: "delete",
- })
-
- const result = await config.api.query.execute(query._id!, {
- parameters: {
- id: "1",
- },
- })
-
- expect(result.data).toEqual([
- {
- deleted: true,
- },
- ])
-
- await withClient(async client => {
- const { rows } = await client.query(
- "SELECT * FROM test_table WHERE id = 1"
- )
- expect(rows).toHaveLength(0)
- })
- })
-})
diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts
index 854410dcf6..f638f2c4bf 100644
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@@ -3,7 +3,7 @@ import { databaseTestProviders } from "../../../integrations/tests/utils"
import tk from "timekeeper"
import { outputProcessing } from "../../../utilities/rowProcessor"
import * as setup from "./utilities"
-import { context, InternalTable, roles, tenancy } from "@budibase/backend-core"
+import { context, InternalTable, tenancy } from "@budibase/backend-core"
import { quotas } from "@budibase/pro"
import {
AutoFieldSubType,
@@ -14,33 +14,21 @@ import {
FieldTypeSubtypes,
FormulaType,
INTERNAL_TABLE_SOURCE_ID,
- PermissionLevel,
QuotaUsageType,
RelationshipType,
Row,
SaveTableRequest,
- SearchQueryOperators,
- SortOrder,
- SortType,
StaticQuotaName,
Table,
TableSourceType,
- ViewV2,
} from "@budibase/types"
-import {
- expectAnyExternalColsAttributes,
- expectAnyInternalColsAttributes,
- generator,
- mocks,
-} from "@budibase/backend-core/tests"
+import { generator, mocks } from "@budibase/backend-core/tests"
import _, { merge } from "lodash"
import * as uuid from "uuid"
const timestamp = new Date("2023-01-26T11:48:57.597Z").toISOString()
tk.freeze(timestamp)
-jest.unmock("mysql2")
-jest.unmock("mysql2/promise")
jest.unmock("mssql")
jest.unmock("pg")
@@ -392,6 +380,23 @@ describe.each([
expect(row.arrayFieldArrayStrKnown).toEqual(["One"])
expect(row.optsFieldStrKnown).toEqual("Alpha")
})
+
+ isInternal &&
+ it("doesn't allow creating in user table", async () => {
+ const userTableId = InternalTable.USER_METADATA
+ const response = await config.api.row.save(
+ userTableId,
+ {
+ tableId: userTableId,
+ firstName: "Joe",
+ lastName: "Joe",
+ email: "joe@joe.com",
+ roles: {},
+ },
+ { status: 400 }
+ )
+ expect(response.message).toBe("Cannot create new user entry.")
+ })
})
describe("get", () => {
@@ -890,642 +895,6 @@ describe.each([
})
})
- describe("view 2.0", () => {
- async function userTable(): Promise {
- return saveTableRequest({
- name: `users_${uuid.v4()}`,
- type: "table",
- schema: {
- name: {
- type: FieldType.STRING,
- name: "name",
- },
- surname: {
- type: FieldType.STRING,
- name: "surname",
- },
- age: {
- type: FieldType.NUMBER,
- name: "age",
- },
- address: {
- type: FieldType.STRING,
- name: "address",
- },
- jobTitle: {
- type: FieldType.STRING,
- name: "jobTitle",
- },
- },
- })
- }
-
- const randomRowData = () => ({
- name: generator.first(),
- surname: generator.last(),
- age: generator.age(),
- address: generator.address(),
- jobTitle: generator.word(),
- })
-
- describe("create", () => {
- it("should persist a new row with only the provided view fields", async () => {
- const table = await config.api.table.save(await userTable())
- const view = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- schema: {
- name: { visible: true },
- surname: { visible: true },
- address: { visible: true },
- },
- })
-
- const data = randomRowData()
- const newRow = await config.api.row.save(view.id, {
- tableId: table!._id,
- _viewId: view.id,
- ...data,
- })
-
- const row = await config.api.row.get(table._id!, newRow._id!)
- expect(row).toEqual({
- name: data.name,
- surname: data.surname,
- address: data.address,
- tableId: table!._id,
- _id: newRow._id,
- _rev: newRow._rev,
- id: newRow.id,
- ...defaultRowFields,
- })
- expect(row._viewId).toBeUndefined()
- expect(row.age).toBeUndefined()
- expect(row.jobTitle).toBeUndefined()
- })
- })
-
- describe("patch", () => {
- it("should update only the view fields for a row", async () => {
- const table = await config.api.table.save(await userTable())
- const tableId = table._id!
- const view = await config.api.viewV2.create({
- tableId: tableId,
- name: generator.guid(),
- schema: {
- name: { visible: true },
- address: { visible: true },
- },
- })
-
- const newRow = await config.api.row.save(view.id, {
- tableId,
- _viewId: view.id,
- ...randomRowData(),
- })
- const newData = randomRowData()
- await config.api.row.patch(view.id, {
- tableId,
- _viewId: view.id,
- _id: newRow._id!,
- _rev: newRow._rev!,
- ...newData,
- })
-
- const row = await config.api.row.get(tableId, newRow._id!)
- expect(row).toEqual({
- ...newRow,
- name: newData.name,
- address: newData.address,
- _id: newRow._id,
- _rev: expect.any(String),
- id: newRow.id,
- ...defaultRowFields,
- })
- expect(row._viewId).toBeUndefined()
- expect(row.age).toBeUndefined()
- expect(row.jobTitle).toBeUndefined()
- })
- })
-
- describe("destroy", () => {
- it("should be able to delete a row", async () => {
- const table = await config.api.table.save(await userTable())
- const tableId = table._id!
- const view = await config.api.viewV2.create({
- tableId: tableId,
- name: generator.guid(),
- schema: {
- name: { visible: true },
- address: { visible: true },
- },
- })
-
- const createdRow = await config.api.row.save(table._id!, {})
- const rowUsage = await getRowUsage()
-
- await config.api.row.bulkDelete(view.id, { rows: [createdRow] })
-
- await assertRowUsage(rowUsage - 1)
-
- await config.api.row.get(tableId, createdRow._id!, {
- status: 404,
- })
- })
-
- it("should be able to delete multiple rows", async () => {
- const table = await config.api.table.save(await userTable())
- const tableId = table._id!
- const view = await config.api.viewV2.create({
- tableId: tableId,
- name: generator.guid(),
- schema: {
- name: { visible: true },
- address: { visible: true },
- },
- })
-
- const rows = await Promise.all([
- config.api.row.save(table._id!, {}),
- config.api.row.save(table._id!, {}),
- config.api.row.save(table._id!, {}),
- ])
- const rowUsage = await getRowUsage()
-
- await config.api.row.bulkDelete(view.id, { rows: [rows[0], rows[2]] })
-
- await assertRowUsage(rowUsage - 2)
-
- await config.api.row.get(tableId, rows[0]._id!, {
- status: 404,
- })
- await config.api.row.get(tableId, rows[2]._id!, {
- status: 404,
- })
- await config.api.row.get(tableId, rows[1]._id!, { status: 200 })
- })
- })
-
- describe("view search", () => {
- let table: Table
- const viewSchema = { age: { visible: true }, name: { visible: true } }
-
- beforeAll(async () => {
- table = await config.api.table.save(
- saveTableRequest({
- name: `users_${uuid.v4()}`,
- schema: {
- name: {
- type: FieldType.STRING,
- name: "name",
- constraints: { type: "string" },
- },
- age: {
- type: FieldType.NUMBER,
- name: "age",
- constraints: {},
- },
- },
- })
- )
- })
-
- it("returns empty rows from view when no schema is passed", async () => {
- const rows = await Promise.all(
- Array.from({ length: 10 }, () =>
- config.api.row.save(table._id!, { tableId: table._id })
- )
- )
-
- const createViewResponse = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- })
- const response = await config.api.viewV2.search(createViewResponse.id)
-
- expect(response.rows).toHaveLength(10)
- expect(response).toEqual({
- rows: expect.arrayContaining(
- rows.map(r => ({
- _viewId: createViewResponse.id,
- tableId: table._id,
- _id: r._id,
- _rev: r._rev,
- ...defaultRowFields,
- }))
- ),
- ...(isInternal
- ? {}
- : {
- hasNextPage: false,
- bookmark: null,
- }),
- })
- })
-
- it("searching respects the view filters", async () => {
- await Promise.all(
- Array.from({ length: 10 }, () =>
- config.api.row.save(table._id!, {
- tableId: table._id,
- name: generator.name(),
- age: generator.integer({ min: 10, max: 30 }),
- })
- )
- )
-
- const expectedRows = await Promise.all(
- Array.from({ length: 5 }, () =>
- config.api.row.save(table._id!, {
- tableId: table._id,
- name: generator.name(),
- age: 40,
- })
- )
- )
-
- const createViewResponse = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- query: [
- { operator: SearchQueryOperators.EQUAL, field: "age", value: 40 },
- ],
- schema: viewSchema,
- })
-
- const response = await config.api.viewV2.search(createViewResponse.id)
-
- expect(response.rows).toHaveLength(5)
- expect(response).toEqual({
- rows: expect.arrayContaining(
- expectedRows.map(r => ({
- _viewId: createViewResponse.id,
- tableId: table._id,
- name: r.name,
- age: r.age,
- _id: r._id,
- _rev: r._rev,
- ...defaultRowFields,
- }))
- ),
- ...(isInternal
- ? {}
- : {
- hasNextPage: false,
- bookmark: null,
- }),
- })
- })
-
- const sortTestOptions: [
- {
- field: string
- order?: SortOrder
- type?: SortType
- },
- string[]
- ][] = [
- [
- {
- field: "name",
- order: SortOrder.ASCENDING,
- type: SortType.STRING,
- },
- ["Alice", "Bob", "Charly", "Danny"],
- ],
- [
- {
- field: "name",
- },
- ["Alice", "Bob", "Charly", "Danny"],
- ],
- [
- {
- field: "name",
- order: SortOrder.DESCENDING,
- },
- ["Danny", "Charly", "Bob", "Alice"],
- ],
- [
- {
- field: "name",
- order: SortOrder.DESCENDING,
- type: SortType.STRING,
- },
- ["Danny", "Charly", "Bob", "Alice"],
- ],
- [
- {
- field: "age",
- order: SortOrder.ASCENDING,
- type: SortType.number,
- },
- ["Danny", "Alice", "Charly", "Bob"],
- ],
- [
- {
- field: "age",
- order: SortOrder.ASCENDING,
- },
- ["Danny", "Alice", "Charly", "Bob"],
- ],
- [
- {
- field: "age",
- order: SortOrder.DESCENDING,
- },
- ["Bob", "Charly", "Alice", "Danny"],
- ],
- [
- {
- field: "age",
- order: SortOrder.DESCENDING,
- type: SortType.number,
- },
- ["Bob", "Charly", "Alice", "Danny"],
- ],
- ]
-
- describe("sorting", () => {
- let table: Table
- beforeAll(async () => {
- table = await config.api.table.save(await userTable())
- const users = [
- { name: "Alice", age: 25 },
- { name: "Bob", age: 30 },
- { name: "Charly", age: 27 },
- { name: "Danny", age: 15 },
- ]
- await Promise.all(
- users.map(u =>
- config.api.row.save(table._id!, {
- tableId: table._id,
- ...u,
- })
- )
- )
- })
-
- it.each(sortTestOptions)(
- "allow sorting (%s)",
- async (sortParams, expected) => {
- const createViewResponse = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- sort: sortParams,
- schema: viewSchema,
- })
-
- const response = await config.api.viewV2.search(
- createViewResponse.id
- )
-
- expect(response.rows).toHaveLength(4)
- expect(response.rows).toEqual(
- expected.map(name => expect.objectContaining({ name }))
- )
- }
- )
-
- it.each(sortTestOptions)(
- "allow override the default view sorting (%s)",
- async (sortParams, expected) => {
- const createViewResponse = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- sort: {
- field: "name",
- order: SortOrder.ASCENDING,
- type: SortType.STRING,
- },
- schema: viewSchema,
- })
-
- const response = await config.api.viewV2.search(
- createViewResponse.id,
- {
- sort: sortParams.field,
- sortOrder: sortParams.order,
- sortType: sortParams.type,
- query: {},
- }
- )
-
- expect(response.rows).toHaveLength(4)
- expect(response.rows).toEqual(
- expected.map(name => expect.objectContaining({ name }))
- )
- }
- )
- })
-
- it("when schema is defined, defined columns and row attributes are returned", async () => {
- const table = await config.api.table.save(await userTable())
- const rows = await Promise.all(
- Array.from({ length: 10 }, () =>
- config.api.row.save(table._id!, {
- tableId: table._id,
- name: generator.name(),
- age: generator.age(),
- })
- )
- )
-
- const view = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- schema: { name: { visible: true } },
- })
- const response = await config.api.viewV2.search(view.id)
-
- expect(response.rows).toHaveLength(10)
- expect(response.rows).toEqual(
- expect.arrayContaining(
- rows.map(r => ({
- ...(isInternal
- ? expectAnyInternalColsAttributes
- : expectAnyExternalColsAttributes),
- _viewId: view.id,
- name: r.name,
- }))
- )
- )
- })
-
- it("views without data can be returned", async () => {
- const table = await config.api.table.save(await userTable())
- const createViewResponse = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- })
- const response = await config.api.viewV2.search(createViewResponse.id)
- expect(response.rows).toHaveLength(0)
- })
-
- it("respects the limit parameter", async () => {
- const table = await config.api.table.save(await userTable())
- await Promise.all(
- Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
- )
-
- const limit = generator.integer({ min: 1, max: 8 })
-
- const createViewResponse = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- })
- const response = await config.api.viewV2.search(createViewResponse.id, {
- limit,
- query: {},
- })
-
- expect(response.rows).toHaveLength(limit)
- })
-
- it("can handle pagination", async () => {
- const table = await config.api.table.save(await userTable())
- await Promise.all(
- Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
- )
- const view = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- })
- const rows = (await config.api.viewV2.search(view.id)).rows
-
- const page1 = await config.api.viewV2.search(view.id, {
- paginate: true,
- limit: 4,
- query: {},
- })
- expect(page1).toEqual({
- rows: expect.arrayContaining(rows.slice(0, 4)),
- totalRows: isInternal ? 10 : undefined,
- hasNextPage: true,
- bookmark: expect.anything(),
- })
-
- const page2 = await config.api.viewV2.search(view.id, {
- paginate: true,
- limit: 4,
- bookmark: page1.bookmark,
-
- query: {},
- })
- expect(page2).toEqual({
- rows: expect.arrayContaining(rows.slice(4, 8)),
- totalRows: isInternal ? 10 : undefined,
- hasNextPage: true,
- bookmark: expect.anything(),
- })
-
- const page3 = await config.api.viewV2.search(view.id, {
- paginate: true,
- limit: 4,
- bookmark: page2.bookmark,
- query: {},
- })
- expect(page3).toEqual({
- rows: expect.arrayContaining(rows.slice(8)),
- totalRows: isInternal ? 10 : undefined,
- hasNextPage: false,
- bookmark: expect.anything(),
- })
- })
-
- isInternal &&
- it("doesn't allow creating in user table", async () => {
- const userTableId = InternalTable.USER_METADATA
- const response = await config.api.row.save(
- userTableId,
- {
- tableId: userTableId,
- firstName: "Joe",
- lastName: "Joe",
- email: "joe@joe.com",
- roles: {},
- },
- { status: 400 }
- )
- expect(response.message).toBe("Cannot create new user entry.")
- })
-
- describe("permissions", () => {
- let table: Table
- let view: ViewV2
-
- beforeAll(async () => {
- table = await config.api.table.save(await userTable())
- await Promise.all(
- Array.from({ length: 10 }, () =>
- config.api.row.save(table._id!, {})
- )
- )
-
- view = await config.api.viewV2.create({
- tableId: table._id!,
- name: generator.guid(),
- })
- })
-
- beforeEach(() => {
- mocks.licenses.useViewPermissions()
- })
-
- it("does not allow public users to fetch by default", async () => {
- await config.publish()
- await config.api.viewV2.publicSearch(view.id, undefined, {
- status: 403,
- })
- })
-
- it("allow public users to fetch when permissions are explicit", async () => {
- await config.api.permission.add({
- roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
- level: PermissionLevel.READ,
- resourceId: view.id,
- })
- await config.publish()
-
- const response = await config.api.viewV2.publicSearch(view.id)
-
- expect(response.rows).toHaveLength(10)
- })
-
- it("allow public users to fetch when permissions are inherited", async () => {
- await config.api.permission.add({
- roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
- level: PermissionLevel.READ,
- resourceId: table._id!,
- })
- await config.publish()
-
- const response = await config.api.viewV2.publicSearch(view.id)
-
- expect(response.rows).toHaveLength(10)
- })
-
- it("respects inherited permissions, not allowing not public views from public tables", async () => {
- await config.api.permission.add({
- roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
- level: PermissionLevel.READ,
- resourceId: table._id!,
- })
- await config.api.permission.add({
- roleId: roles.BUILTIN_ROLE_IDS.POWER,
- level: PermissionLevel.READ,
- resourceId: view.id,
- })
- await config.publish()
-
- await config.api.viewV2.publicSearch(view.id, undefined, {
- status: 403,
- })
- })
- })
- })
- })
-
let o2mTable: Table
let m2mTable: Table
beforeAll(async () => {
diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts
index ded5e08d29..f9d213a26b 100644
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@@ -5,23 +5,26 @@ import {
FieldSchema,
FieldType,
INTERNAL_TABLE_SOURCE_ID,
+ PermissionLevel,
+ QuotaUsageType,
SaveTableRequest,
SearchQueryOperators,
SortOrder,
SortType,
+ StaticQuotaName,
Table,
TableSourceType,
UIFieldMetadata,
UpdateViewRequest,
ViewV2,
} from "@budibase/types"
-import { generator } from "@budibase/backend-core/tests"
+import { generator, mocks } from "@budibase/backend-core/tests"
import * as uuid from "uuid"
import { databaseTestProviders } from "../../../integrations/tests/utils"
import merge from "lodash/merge"
+import { quotas } from "@budibase/pro"
+import { roles } from "@budibase/backend-core"
-jest.unmock("mysql2")
-jest.unmock("mysql2/promise")
jest.unmock("mssql")
jest.unmock("pg")
@@ -33,6 +36,7 @@ describe.each([
["mariadb", databaseTestProviders.mariadb],
])("/v2/views (%s)", (_, dsProvider) => {
const config = setup.getConfig()
+ const isInternal = !dsProvider
let table: Table
let datasource: Datasource
@@ -99,6 +103,18 @@ describe.each([
setup.afterAll()
})
+ const getRowUsage = async () => {
+ const { total } = await config.doInContext(undefined, () =>
+ quotas.getCurrentUsageValues(QuotaUsageType.STATIC, StaticQuotaName.ROWS)
+ )
+ return total
+ }
+
+ const assertRowUsage = async (expected: number) => {
+ const usage = await getRowUsage()
+ expect(usage).toBe(expected)
+ }
+
describe("create", () => {
it("persist the view when the view is successfully created", async () => {
const newView: CreateViewRequest = {
@@ -525,4 +541,468 @@ describe.each([
expect(row.Country).toEqual("Aussy")
})
})
+
+ describe("row operations", () => {
+ let table: Table, view: ViewV2
+ beforeEach(async () => {
+ table = await config.api.table.save(
+ saveTableRequest({
+ schema: {
+ one: { type: FieldType.STRING, name: "one" },
+ two: { type: FieldType.STRING, name: "two" },
+ },
+ })
+ )
+ view = await config.api.viewV2.create({
+ tableId: table._id!,
+ name: generator.guid(),
+ schema: {
+ two: { visible: true },
+ },
+ })
+ })
+
+ describe("create", () => {
+ it("should persist a new row with only the provided view fields", async () => {
+ const newRow = await config.api.row.save(view.id, {
+ tableId: table!._id,
+ _viewId: view.id,
+ one: "foo",
+ two: "bar",
+ })
+
+ const row = await config.api.row.get(table._id!, newRow._id!)
+ expect(row.one).toBeUndefined()
+ expect(row.two).toEqual("bar")
+ })
+ })
+
+ describe("patch", () => {
+ it("should update only the view fields for a row", async () => {
+ const newRow = await config.api.row.save(table._id!, {
+ one: "foo",
+ two: "bar",
+ })
+ await config.api.row.patch(view.id, {
+ tableId: table._id!,
+ _id: newRow._id!,
+ _rev: newRow._rev!,
+ one: "newFoo",
+ two: "newBar",
+ })
+
+ const row = await config.api.row.get(table._id!, newRow._id!)
+ expect(row.one).toEqual("foo")
+ expect(row.two).toEqual("newBar")
+ })
+ })
+
+ describe("destroy", () => {
+ it("should be able to delete a row", async () => {
+ const createdRow = await config.api.row.save(table._id!, {})
+ const rowUsage = await getRowUsage()
+ await config.api.row.bulkDelete(view.id, { rows: [createdRow] })
+ await assertRowUsage(rowUsage - 1)
+ await config.api.row.get(table._id!, createdRow._id!, {
+ status: 404,
+ })
+ })
+
+ it("should be able to delete multiple rows", async () => {
+ const rows = await Promise.all([
+ config.api.row.save(table._id!, {}),
+ config.api.row.save(table._id!, {}),
+ config.api.row.save(table._id!, {}),
+ ])
+ const rowUsage = await getRowUsage()
+
+ await config.api.row.bulkDelete(view.id, { rows: [rows[0], rows[2]] })
+
+ await assertRowUsage(rowUsage - 2)
+
+ await config.api.row.get(table._id!, rows[0]._id!, {
+ status: 404,
+ })
+ await config.api.row.get(table._id!, rows[2]._id!, {
+ status: 404,
+ })
+ await config.api.row.get(table._id!, rows[1]._id!, { status: 200 })
+ })
+ })
+
+ describe("search", () => {
+ it("returns empty rows from view when no schema is passed", async () => {
+ const rows = await Promise.all(
+ Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+ )
+ const response = await config.api.viewV2.search(view.id)
+ expect(response.rows).toHaveLength(10)
+ expect(response).toEqual({
+ rows: expect.arrayContaining(
+ rows.map(r => ({
+ _viewId: view.id,
+ tableId: table._id,
+ _id: r._id,
+ _rev: r._rev,
+ ...(isInternal
+ ? {
+ type: "row",
+ updatedAt: expect.any(String),
+ createdAt: expect.any(String),
+ }
+ : {}),
+ }))
+ ),
+ ...(isInternal
+ ? {}
+ : {
+ hasNextPage: false,
+ bookmark: null,
+ }),
+ })
+ })
+
+ it("searching respects the view filters", async () => {
+ await config.api.row.save(table._id!, {
+ one: "foo",
+ two: "bar",
+ })
+ const two = await config.api.row.save(table._id!, {
+ one: "foo2",
+ two: "bar2",
+ })
+
+ const view = await config.api.viewV2.create({
+ tableId: table._id!,
+ name: generator.guid(),
+ query: [
+ {
+ operator: SearchQueryOperators.EQUAL,
+ field: "two",
+ value: "bar2",
+ },
+ ],
+ schema: {
+ two: { visible: true },
+ },
+ })
+
+ const response = await config.api.viewV2.search(view.id)
+ expect(response.rows).toHaveLength(1)
+ expect(response).toEqual({
+ rows: expect.arrayContaining([
+ {
+ _viewId: view.id,
+ tableId: table._id,
+ two: two.two,
+ _id: two._id,
+ _rev: two._rev,
+ ...(isInternal
+ ? {
+ type: "row",
+ createdAt: expect.any(String),
+ updatedAt: expect.any(String),
+ }
+ : {}),
+ },
+ ]),
+ ...(isInternal
+ ? {}
+ : {
+ hasNextPage: false,
+ bookmark: null,
+ }),
+ })
+ })
+
+ it("views without data can be returned", async () => {
+ const response = await config.api.viewV2.search(view.id)
+ expect(response.rows).toHaveLength(0)
+ })
+
+ it("respects the limit parameter", async () => {
+ await Promise.all(
+ Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+ )
+ const limit = generator.integer({ min: 1, max: 8 })
+ const response = await config.api.viewV2.search(view.id, {
+ limit,
+ query: {},
+ })
+ expect(response.rows).toHaveLength(limit)
+ })
+
+ it("can handle pagination", async () => {
+ await Promise.all(
+ Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+ )
+ const rows = (await config.api.viewV2.search(view.id)).rows
+
+ const page1 = await config.api.viewV2.search(view.id, {
+ paginate: true,
+ limit: 4,
+ query: {},
+ })
+ expect(page1).toEqual({
+ rows: expect.arrayContaining(rows.slice(0, 4)),
+ totalRows: isInternal ? 10 : undefined,
+ hasNextPage: true,
+ bookmark: expect.anything(),
+ })
+
+ const page2 = await config.api.viewV2.search(view.id, {
+ paginate: true,
+ limit: 4,
+ bookmark: page1.bookmark,
+ query: {},
+ })
+ expect(page2).toEqual({
+ rows: expect.arrayContaining(rows.slice(4, 8)),
+ totalRows: isInternal ? 10 : undefined,
+ hasNextPage: true,
+ bookmark: expect.anything(),
+ })
+
+ const page3 = await config.api.viewV2.search(view.id, {
+ paginate: true,
+ limit: 4,
+ bookmark: page2.bookmark,
+ query: {},
+ })
+ expect(page3).toEqual({
+ rows: expect.arrayContaining(rows.slice(8)),
+ totalRows: isInternal ? 10 : undefined,
+ hasNextPage: false,
+ bookmark: expect.anything(),
+ })
+ })
+
+ const sortTestOptions: [
+ {
+ field: string
+ order?: SortOrder
+ type?: SortType
+ },
+ string[]
+ ][] = [
+ [
+ {
+ field: "name",
+ order: SortOrder.ASCENDING,
+ type: SortType.STRING,
+ },
+ ["Alice", "Bob", "Charly", "Danny"],
+ ],
+ [
+ {
+ field: "name",
+ },
+ ["Alice", "Bob", "Charly", "Danny"],
+ ],
+ [
+ {
+ field: "name",
+ order: SortOrder.DESCENDING,
+ },
+ ["Danny", "Charly", "Bob", "Alice"],
+ ],
+ [
+ {
+ field: "name",
+ order: SortOrder.DESCENDING,
+ type: SortType.STRING,
+ },
+ ["Danny", "Charly", "Bob", "Alice"],
+ ],
+ [
+ {
+ field: "age",
+ order: SortOrder.ASCENDING,
+ type: SortType.number,
+ },
+ ["Danny", "Alice", "Charly", "Bob"],
+ ],
+ [
+ {
+ field: "age",
+ order: SortOrder.ASCENDING,
+ },
+ ["Danny", "Alice", "Charly", "Bob"],
+ ],
+ [
+ {
+ field: "age",
+ order: SortOrder.DESCENDING,
+ },
+ ["Bob", "Charly", "Alice", "Danny"],
+ ],
+ [
+ {
+ field: "age",
+ order: SortOrder.DESCENDING,
+ type: SortType.number,
+ },
+ ["Bob", "Charly", "Alice", "Danny"],
+ ],
+ ]
+
+ describe("sorting", () => {
+ let table: Table
+ const viewSchema = { age: { visible: true }, name: { visible: true } }
+
+ beforeAll(async () => {
+ table = await config.api.table.save(
+ saveTableRequest({
+ name: `users_${uuid.v4()}`,
+ type: "table",
+ schema: {
+ name: {
+ type: FieldType.STRING,
+ name: "name",
+ },
+ surname: {
+ type: FieldType.STRING,
+ name: "surname",
+ },
+ age: {
+ type: FieldType.NUMBER,
+ name: "age",
+ },
+ address: {
+ type: FieldType.STRING,
+ name: "address",
+ },
+ jobTitle: {
+ type: FieldType.STRING,
+ name: "jobTitle",
+ },
+ },
+ })
+ )
+
+ const users = [
+ { name: "Alice", age: 25 },
+ { name: "Bob", age: 30 },
+ { name: "Charly", age: 27 },
+ { name: "Danny", age: 15 },
+ ]
+ await Promise.all(
+ users.map(u =>
+ config.api.row.save(table._id!, {
+ tableId: table._id,
+ ...u,
+ })
+ )
+ )
+ })
+
+ it.each(sortTestOptions)(
+ "allow sorting (%s)",
+ async (sortParams, expected) => {
+ const view = await config.api.viewV2.create({
+ tableId: table._id!,
+ name: generator.guid(),
+ sort: sortParams,
+ schema: viewSchema,
+ })
+
+ const response = await config.api.viewV2.search(view.id)
+
+ expect(response.rows).toHaveLength(4)
+ expect(response.rows).toEqual(
+ expected.map(name => expect.objectContaining({ name }))
+ )
+ }
+ )
+
+ it.each(sortTestOptions)(
+ "allow override the default view sorting (%s)",
+ async (sortParams, expected) => {
+ const view = await config.api.viewV2.create({
+ tableId: table._id!,
+ name: generator.guid(),
+ sort: {
+ field: "name",
+ order: SortOrder.ASCENDING,
+ type: SortType.STRING,
+ },
+ schema: viewSchema,
+ })
+
+ const response = await config.api.viewV2.search(view.id, {
+ sort: sortParams.field,
+ sortOrder: sortParams.order,
+ sortType: sortParams.type,
+ query: {},
+ })
+
+ expect(response.rows).toHaveLength(4)
+ expect(response.rows).toEqual(
+ expected.map(name => expect.objectContaining({ name }))
+ )
+ }
+ )
+ })
+ })
+
+ describe("permissions", () => {
+ beforeEach(async () => {
+ mocks.licenses.useViewPermissions()
+ await Promise.all(
+ Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+ )
+ })
+
+ it("does not allow public users to fetch by default", async () => {
+ await config.publish()
+ await config.api.viewV2.publicSearch(view.id, undefined, {
+ status: 403,
+ })
+ })
+
+ it("allow public users to fetch when permissions are explicit", async () => {
+ await config.api.permission.add({
+ roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
+ level: PermissionLevel.READ,
+ resourceId: view.id,
+ })
+ await config.publish()
+
+ const response = await config.api.viewV2.publicSearch(view.id)
+
+ expect(response.rows).toHaveLength(10)
+ })
+
+ it("allow public users to fetch when permissions are inherited", async () => {
+ await config.api.permission.add({
+ roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
+ level: PermissionLevel.READ,
+ resourceId: table._id!,
+ })
+ await config.publish()
+
+ const response = await config.api.viewV2.publicSearch(view.id)
+
+ expect(response.rows).toHaveLength(10)
+ })
+
+ it("respects inherited permissions, not allowing not public views from public tables", async () => {
+ await config.api.permission.add({
+ roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
+ level: PermissionLevel.READ,
+ resourceId: table._id!,
+ })
+ await config.api.permission.add({
+ roleId: roles.BUILTIN_ROLE_IDS.POWER,
+ level: PermissionLevel.READ,
+ resourceId: view.id,
+ })
+ await config.publish()
+
+ await config.api.viewV2.publicSearch(view.id, undefined, {
+ status: 403,
+ })
+ })
+ })
+ })
})
diff --git a/packages/server/src/integration-test/mysql.spec.ts b/packages/server/src/integration-test/mysql.spec.ts
index a22410b812..92420fb336 100644
--- a/packages/server/src/integration-test/mysql.spec.ts
+++ b/packages/server/src/integration-test/mysql.spec.ts
@@ -20,7 +20,6 @@ fetch.mockSearch()
const config = setup.getConfig()!
-jest.unmock("mysql2/promise")
jest.mock("../websockets", () => ({
clientAppSocket: jest.fn(),
gridAppSocket: jest.fn(),
diff --git a/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts b/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts
deleted file mode 100644
index eaaa79f7c9..0000000000
--- a/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { default as MSSQLIntegration } from "../microsoftSqlServer"
-
-jest.mock("mssql")
-
-class TestConfiguration {
- integration: any
-
- constructor(config: any = {}) {
- this.integration = new MSSQLIntegration.integration(config)
- }
-}
-
-describe("MS SQL Server Integration", () => {
- let config: any
-
- beforeEach(async () => {
- config = new TestConfiguration()
- })
-
- describe("check sql used", () => {
- beforeEach(async () => {
- await config.integration.connect()
- })
-
- it("calls the create method with the correct params", async () => {
- const sql = "insert into users (name, age) values ('Joe', 123);"
- const response = await config.integration.create({
- sql,
- })
- expect(config.integration.client.request).toHaveBeenCalledWith()
- expect(response[0]).toEqual(sql)
- })
-
- it("calls the read method with the correct params", async () => {
- const sql = "select * from users;"
- const response = await config.integration.read({
- sql,
- })
- expect(config.integration.client.request).toHaveBeenCalledWith()
- expect(response[0]).toEqual(sql)
- })
- })
-
- describe("no rows returned", () => {
- beforeEach(async () => {
- await config.integration.connect()
- })
-
- it("returns the correct response when the create response has no rows", async () => {
- const sql = "insert into users (name, age) values ('Joe', 123);"
- const response = await config.integration.create({
- sql,
- })
- expect(response[0]).toEqual(sql)
- })
- })
-})
diff --git a/packages/server/src/integrations/tests/mysql.spec.ts b/packages/server/src/integrations/tests/mysql.spec.ts
deleted file mode 100644
index 5180645885..0000000000
--- a/packages/server/src/integrations/tests/mysql.spec.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { default as MySQLIntegration, bindingTypeCoerce } from "../mysql"
-
-jest.mock("mysql2")
-
-class TestConfiguration {
- integration: any
-
- constructor(config: any = { ssl: {} }) {
- this.integration = new MySQLIntegration.integration(config)
- }
-}
-
-describe("MySQL Integration", () => {
- let config: any
-
- beforeEach(() => {
- config = new TestConfiguration()
- })
-
- it("calls the create method with the correct params", async () => {
- const sql = "insert into users (name, age) values ('Joe', 123);"
- await config.integration.create({
- sql,
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
- })
-
- it("calls the read method with the correct params", async () => {
- const sql = "select * from users;"
- await config.integration.read({
- sql,
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
- })
-
- it("calls the update method with the correct params", async () => {
- const sql = "update table users set name = 'test';"
- await config.integration.update({
- sql,
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
- })
-
- it("calls the delete method with the correct params", async () => {
- const sql = "delete from users where name = 'todelete';"
- await config.integration.delete({
- sql,
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
- })
-
- describe("no rows returned", () => {
- it("returns the correct response when the create response has no rows", async () => {
- const sql = "insert into users (name, age) values ('Joe', 123);"
- const response = await config.integration.create({
- sql,
- })
- expect(response).toEqual([{ created: true }])
- })
-
- it("returns the correct response when the update response has no rows", async () => {
- const sql = "update table users set name = 'test';"
- const response = await config.integration.update({
- sql,
- })
- expect(response).toEqual([{ updated: true }])
- })
-
- it("returns the correct response when the delete response has no rows", async () => {
- const sql = "delete from users where name = 'todelete';"
- const response = await config.integration.delete({
- sql,
- })
- expect(response).toEqual([{ deleted: true }])
- })
- })
-
- describe("binding type coerce", () => {
- it("ignores non-string types", async () => {
- const sql = "select * from users;"
- const date = new Date()
- await config.integration.read({
- sql,
- bindings: [11, date, ["a", "b", "c"], { id: 1 }],
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [
- 11,
- date,
- ["a", "b", "c"],
- { id: 1 },
- ])
- })
-
- it("parses strings matching a number regex", async () => {
- const sql = "select * from users;"
- await config.integration.read({
- sql,
- bindings: ["101", "3.14"],
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(
- sql,
- [101, 3.14]
- )
- })
-
- it("parses strings matching a valid date format", async () => {
- const sql = "select * from users;"
- await config.integration.read({
- sql,
- bindings: [
- "2001-10-30",
- "2010-09-01T13:30:59.123Z",
- "2021-02-05 12:01 PM",
- ],
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [
- new Date("2001-10-30T00:00:00.000Z"),
- new Date("2010-09-01T13:30:59.123Z"),
- new Date("2021-02-05T12:01:00.000Z"),
- ])
- })
-
- it("does not parse string matching a valid array of numbers as date", async () => {
- const sql = "select * from users;"
- await config.integration.read({
- sql,
- bindings: ["1,2,2017"],
- })
- expect(config.integration.client.query).toHaveBeenCalledWith(sql, [
- "1,2,2017",
- ])
- })
- })
-})
-
-describe("bindingTypeCoercion", () => {
- it("shouldn't coerce something that looks like a date", () => {
- const response = bindingTypeCoerce(["202205-1500"])
- expect(response[0]).toBe("202205-1500")
- })
-
- it("should coerce an actual date", () => {
- const date = new Date("2023-06-13T14:24:22.620Z")
- const response = bindingTypeCoerce(["2023-06-13T14:24:22.620Z"])
- expect(response[0]).toEqual(date)
- })
-
- it("should coerce numbers", () => {
- const response = bindingTypeCoerce(["0"])
- expect(response[0]).toEqual(0)
- })
-})
diff --git a/packages/server/src/integrations/tests/postgres.spec.ts b/packages/server/src/integrations/tests/postgres.spec.ts
deleted file mode 100644
index cbce86acd0..0000000000
--- a/packages/server/src/integrations/tests/postgres.spec.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-const pg = require("pg")
-
-import { default as PostgresIntegration } from "../postgres"
-
-jest.mock("pg")
-
-class TestConfiguration {
- integration: any
-
- constructor(config: any = {}) {
- this.integration = new PostgresIntegration.integration(config)
- }
-}
-
-describe("Postgres Integration", () => {
- let config: any
-
- beforeEach(() => {
- config = new TestConfiguration()
- })
-
- it("calls the create method with the correct params", async () => {
- const sql = "insert into users (name, age) values ('Joe', 123);"
- await config.integration.create({
- sql,
- })
- expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
- })
-
- it("calls the read method with the correct params", async () => {
- const sql = "select * from users;"
- await config.integration.read({
- sql,
- })
- expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
- })
-
- it("calls the update method with the correct params", async () => {
- const sql = "update table users set name = 'test';"
- await config.integration.update({
- sql,
- })
- expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
- })
-
- it("calls the delete method with the correct params", async () => {
- const sql = "delete from users where name = 'todelete';"
- await config.integration.delete({
- sql,
- })
- expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
- })
-
- describe("no rows returned", () => {
- beforeEach(() => {
- pg.queryMock.mockImplementation(() => ({ rows: [] }))
- })
-
- it("returns the correct response when the create response has no rows", async () => {
- const sql = "insert into users (name, age) values ('Joe', 123);"
- const response = await config.integration.create({
- sql,
- })
- expect(response).toEqual([{ created: true }])
- })
-
- it("returns the correct response when the update response has no rows", async () => {
- const sql = "update table users set name = 'test';"
- const response = await config.integration.update({
- sql,
- })
- expect(response).toEqual([{ updated: true }])
- })
-
- it("returns the correct response when the delete response has no rows", async () => {
- const sql = "delete from users where name = 'todelete';"
- const response = await config.integration.delete({
- sql,
- })
- expect(response).toEqual([{ deleted: true }])
- })
- })
-})
diff --git a/packages/server/src/integrations/tests/utils/mssql.ts b/packages/server/src/integrations/tests/utils/mssql.ts
index f548f0c42c..6bd4290a90 100644
--- a/packages/server/src/integrations/tests/utils/mssql.ts
+++ b/packages/server/src/integrations/tests/utils/mssql.ts
@@ -41,6 +41,9 @@ export async function datasource(): Promise {
port,
user: "sa",
password: "Password_123",
+ options: {
+ encrypt: false,
+ },
},
}
}
diff --git a/packages/server/src/sdk/app/rows/search/tests/external.spec.ts b/packages/server/src/sdk/app/rows/search/tests/external.spec.ts
index bae84592ca..8ecec784dd 100644
--- a/packages/server/src/sdk/app/rows/search/tests/external.spec.ts
+++ b/packages/server/src/sdk/app/rows/search/tests/external.spec.ts
@@ -17,8 +17,6 @@ import {
generator,
} from "@budibase/backend-core/tests"
-jest.unmock("mysql2/promise")
-
jest.setTimeout(30000)
describe("external search", () => {
diff --git a/packages/string-templates/src/helpers/list.ts b/packages/string-templates/src/helpers/list.ts
index 361558e04d..5852bc9127 100644
--- a/packages/string-templates/src/helpers/list.ts
+++ b/packages/string-templates/src/helpers/list.ts
@@ -1,17 +1,30 @@
import { date, duration } from "./date"
+import {
+ math,
+ array,
+ number,
+ url,
+ string,
+ comparison,
+ object,
+ regex,
+ uuid,
+ // @ts-expect-error
+} from "@budibase/handlebars-helpers"
+
// https://github.com/evanw/esbuild/issues/56
-const getExternalCollections = (): Record any> => ({
- math: require("@budibase/handlebars-helpers/lib/math"),
- array: require("@budibase/handlebars-helpers/lib/array"),
- number: require("@budibase/handlebars-helpers/lib/number"),
- url: require("@budibase/handlebars-helpers/lib/url"),
- string: require("@budibase/handlebars-helpers/lib/string"),
- comparison: require("@budibase/handlebars-helpers/lib/comparison"),
- object: require("@budibase/handlebars-helpers/lib/object"),
- regex: require("@budibase/handlebars-helpers/lib/regex"),
- uuid: require("@budibase/handlebars-helpers/lib/uuid"),
-})
+const externalCollections = {
+ math,
+ array,
+ number,
+ url,
+ string,
+ comparison,
+ object,
+ regex,
+ uuid,
+}
export const helpersToRemoveForJs = ["sortBy"]
@@ -28,8 +41,8 @@ export function getJsHelperList() {
}
helpers = {}
- for (let collection of Object.values(getExternalCollections())) {
- for (let [key, func] of Object.entries(collection)) {
+ for (let collection of Object.values(externalCollections)) {
+ for (let [key, func] of Object.entries(collection())) {
// Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it
helpers[key] = (...props: any) => func(...props, {})
}
diff --git a/qa-core/src/integrations/external-schema/mysql.integration.spec.ts b/qa-core/src/integrations/external-schema/mysql.integration.spec.ts
index c34651ea0e..5a7e1989d2 100644
--- a/qa-core/src/integrations/external-schema/mysql.integration.spec.ts
+++ b/qa-core/src/integrations/external-schema/mysql.integration.spec.ts
@@ -1,8 +1,6 @@
import { GenericContainer } from "testcontainers"
import mysql from "../../../../packages/server/src/integrations/mysql"
-jest.unmock("mysql2/promise")
-
describe("datasource validators", () => {
describe("mysql", () => {
let config: any
diff --git a/qa-core/src/integrations/validators/mysql.integration.spec.ts b/qa-core/src/integrations/validators/mysql.integration.spec.ts
index 0f0de132fe..e828d192af 100644
--- a/qa-core/src/integrations/validators/mysql.integration.spec.ts
+++ b/qa-core/src/integrations/validators/mysql.integration.spec.ts
@@ -1,8 +1,6 @@
import { GenericContainer } from "testcontainers"
import mysql from "../../../../packages/server/src/integrations/mysql"
-jest.unmock("mysql2/promise")
-
describe("datasource validators", () => {
describe("mysql", () => {
let host: string