MirrorSave
/
budibase
mirror of https://github.com/Budibase/budibase.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:Budibase/budibase into labday/sqs

This commit is contained in:
mike12345567 2024-03-21 15:01:20 +00:00
parent 9995f71871 ed94459fd8
commit 3a05076c3e
35 changed files with 1087 additions and 1621 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lerna.json
View File

@ -1,5 +1,5 @@
{
"version": "2.22.6",
"version": "2.22.9",
"npmClient": "yarn",
"packages": [
"packages/*",

13
packages/bbui/src/Actions/click_outside.js
View File

@ -39,19 +39,23 @@ const handleClick = event => {
return
}
if (handler.allowedType && event.type !== handler.allowedType) {
return
}
handler.callback?.(event)
})
}
document.documentElement.addEventListener("click", handleClick, true)
document.documentElement.addEventListener("contextmenu", handleClick, true)
document.documentElement.addEventListener("mousedown", handleClick, true)
/**
* Adds or updates a click handler
*/
const updateHandler = (id, element, anchor, callback) => {
const updateHandler = (id, element, anchor, callback, allowedType) => {
let existingHandler = clickHandlers.find(x => x.id === id)
if (!existingHandler) {
clickHandlers.push({ id, element, anchor, callback })
clickHandlers.push({ id, element, anchor, callback, allowedType })
} else {
existingHandler.callback = callback
}
@ -77,7 +81,8 @@ export default (element, opts) => {
const update = newOpts => {
const callback = newOpts?.callback || newOpts
const anchor = newOpts?.anchor || element
updateHandler(id, element, anchor, callback)
const allowedType = newOpts?.allowedType || "click"
updateHandler(id, element, anchor, callback, allowedType)
}
update(opts)
return {

24
packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
View File

@ -34,7 +34,12 @@
import { getBindings } from "components/backend/DataTable/formula"
import JSONSchemaModal from "./JSONSchemaModal.svelte"
import { ValidColumnNameRegex } from "@budibase/shared-core"
import { FieldType, FieldSubtype, SourceName } from "@budibase/types"
import {
FieldType,
FieldSubtype,
SourceName,
FieldTypeSubtypes,
} from "@budibase/types"
import RelationshipSelector from "components/common/RelationshipSelector.svelte"
import { RowUtils } from "@budibase/frontend-core"
import ServerBindingPanel from "components/common/bindings/ServerBindingPanel.svelte"
@ -191,8 +196,10 @@
// don't make field IDs for auto types
if (type === AUTO_TYPE || autocolumn) {
return type.toUpperCase()
} else {
} else if (type === FieldType.BB_REFERENCE) {
return `${type}${subtype || ""}`.toUpperCase()
} else {
return type.toUpperCase()
}
}
@ -705,17 +712,14 @@
/>
{:else if editableColumn.type === FieldType.ATTACHMENT}
<Toggle
value={editableColumn.constraints?.length?.maximum !== 1}
value={editableColumn.subtype !== FieldTypeSubtypes.ATTACHMENT.SINGLE &&
// Checking config before the subtype was added
editableColumn.constraints?.length?.maximum !== 1}
on:change={e => {
if (!e.detail) {
editableColumn.constraints ??= { length: {} }
editableColumn.constraints.length ??= {}
editableColumn.constraints.length.maximum = 1
editableColumn.constraints.length.message =
"cannot contain multiple files"
editableColumn.subtype = FieldTypeSubtypes.ATTACHMENT.SINGLE
} else {
delete editableColumn.constraints?.length?.maximum
delete editableColumn.constraints?.length?.message
delete editableColumn.subtype
}
}}
thin

23
packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
View File

@ -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 @@
}
</script>
{#if allowDeletion}
<ActionMenu>
<div slot="control" class="icon">
<Icon s hoverable name="MoreSmallList" />
</div>
{#if !externalTable}
<MenuItem icon="Edit" on:click={editorModal.show}>Edit</MenuItem>
{/if}
<MenuItem icon="Delete" on:click={showDeleteModal}>Delete</MenuItem>
</ActionMenu>
{/if}
<ActionMenu>
<div slot="control" class="icon">
<Icon s hoverable name="MoreSmallList" />
</div>
{#if !externalTable}
<MenuItem icon="Edit" on:click={editorModal.show}>Edit</MenuItem>
{/if}
<MenuItem icon="Delete" on:click={showDeleteModal}>Delete</MenuItem>
</ActionMenu>
<Modal bind:this={editorModal} on:show={initForm}>
<ModalContent

5
packages/client/src/components/app/Layout.svelte
View File

@ -291,7 +291,10 @@
<div
id="side-panel-container"
class:open={$sidePanelStore.open}
use:clickOutside={autoCloseSidePanel ? sidePanelStore.actions.close : null}
use:clickOutside={{
callback: autoCloseSidePanel ? sidePanelStore.actions.close : null,
allowedType: "mousedown",
}}
class:builder={$builderStore.inBuilder}
>
<div class="side-panel-header">

42
packages/client/src/components/app/blocks/TableBlock.svelte
View File

@ -1,5 +1,6 @@
<script>
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") {

12
packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
View File

@ -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")

17
packages/server/__mocks__/mssql.ts
View File

@ -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,
},
],
})),
}

11
packages/server/__mocks__/mysql2.ts
View File

@ -1,11 +0,0 @@
const client = {
connect: jest.fn(),
query: jest.fn((query, bindings, fn) => {
fn(null, [])
}),
}
module.exports = {
createConnection: jest.fn(() => client),
client,
}

18
packages/server/__mocks__/mysql2/promise.ts
View File

@ -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
}

3
packages/server/src/api/controllers/table/external.ts
View File

@ -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(

23
packages/server/src/api/controllers/table/utils.ts
View File

@ -31,6 +31,8 @@ import {
View,
RelationshipFieldMetadata,
FieldType,
FieldTypeSubtypes,
AttachmentFieldMetadata,
} from "@budibase/types"
export async function clearColumns(table: Table, columnNames: string[]) {
@ -89,6 +91,27 @@ export async function checkForColumnUpdates(
// Update views
await checkForViewUpdates(updatedTable, deletedColumns, columnRename)
}
const changedAttachmentSubtypeColumns = Object.values(
updatedTable.schema
).filter(
(column): column is AttachmentFieldMetadata =>
column.type === FieldType.ATTACHMENT &&
column.subtype !== oldTable?.schema[column.name]?.subtype
)
for (const attachmentColumn of changedAttachmentSubtypeColumns) {
if (attachmentColumn.subtype === FieldTypeSubtypes.ATTACHMENT.SINGLE) {
attachmentColumn.constraints ??= { length: {} }
attachmentColumn.constraints.length ??= {}
attachmentColumn.constraints.length.maximum = 1
attachmentColumn.constraints.length.message =
"cannot contain multiple files"
} else {
delete attachmentColumn.constraints?.length?.maximum
delete attachmentColumn.constraints?.length?.message
}
}
return { rows: updatedRows, table: updatedTable }
}

43
packages/server/src/api/routes/tests/debug.spec.ts
View File

@ -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\)$/
),
})
})

401
packages/server/src/api/routes/tests/queries/generic-sql.spec.ts Normal file
View File

@ -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<string, string> = {
[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<Query>): Promise<Query> {
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<any> {
// 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)
})
})
})

239
packages/server/src/api/routes/tests/queries/mysql.spec.ts
View File

@ -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<Query>): Promise<Query> {
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<void>
): Promise<void> {
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)
})
})
})

243
packages/server/src/api/routes/tests/queries/postgres.spec.ts
View File

@ -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<Query>): Promise<Query> {
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<void>
): Promise<void> {
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)
})
})
})

669
packages/server/src/api/routes/tests/row.spec.ts
View File

@ -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<Table> {
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 () => {

486
packages/server/src/api/routes/tests/viewV2.spec.ts
View File

@ -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,
})
})
})
})
})

1
packages/server/src/integration-test/mysql.spec.ts
View File

@ -20,7 +20,6 @@ fetch.mockSearch()
const config = setup.getConfig()!
jest.unmock("mysql2/promise")
jest.mock("../websockets", () => ({
clientAppSocket: jest.fn(),
gridAppSocket: jest.fn(),

2
packages/server/src/integrations/base/sqlTable.ts
View File

@ -61,7 +61,7 @@ function generateSchema(
schema.text(key)
break
case FieldType.BB_REFERENCE: {
const subtype = column.subtype as FieldSubtype
const subtype = column.subtype
switch (subtype) {
case FieldSubtype.USER:
schema.text(key)

57
packages/server/src/integrations/tests/microsoftSqlServer.spec.ts
View File

@ -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)
})
})
})

152
packages/server/src/integrations/tests/mysql.spec.ts
View File

@ -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)
})
})

83
packages/server/src/integrations/tests/postgres.spec.ts
View File

@ -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 }])
})
})
})

3
packages/server/src/integrations/tests/utils/mssql.ts
View File

@ -41,6 +41,9 @@ export async function datasource(): Promise<Datasource> {
port,
user: "sa",
password: "Password_123",
options: {
encrypt: false,
},
},
}
}

2
packages/server/src/sdk/app/rows/search/tests/external.spec.ts
View File

@ -17,8 +17,6 @@ import {
generator,
} from "@budibase/backend-core/tests"
jest.unmock("mysql2/promise")
jest.setTimeout(30000)
describe("external search", () => {

2
packages/server/src/sdk/app/rows/search/utils.ts
View File

@ -67,7 +67,7 @@ export function searchInputMapping(table: Table, options: SearchParams) {
for (let [key, column] of Object.entries(table.schema)) {
switch (column.type) {
case FieldType.BB_REFERENCE: {
const subtype = column.subtype as FieldSubtype
const subtype = column.subtype
switch (subtype) {
case FieldSubtype.USER:
case FieldSubtype.USERS:

4
packages/server/src/utilities/rowProcessor/bbReferenceProcessor.ts
View File

@ -7,7 +7,7 @@ const ROW_PREFIX = DocumentType.ROW + SEPARATOR
export async function processInputBBReferences(
value: string | string[] | { _id: string } | { _id: string }[],
subtype: FieldSubtype
subtype: FieldSubtype.USER | FieldSubtype.USERS
): Promise<string | string[] | null> {
let referenceIds: string[] = []
@ -61,7 +61,7 @@ export async function processInputBBReferences(
export async function processOutputBBReferences(
value: string | string[],
subtype: FieldSubtype
subtype: FieldSubtype.USER | FieldSubtype.USERS
) {
if (value === null || value === undefined) {
// Already processed or nothing to process

8
packages/server/src/utilities/rowProcessor/index.ts
View File

@ -6,7 +6,6 @@ import { TYPE_TRANSFORM_MAP } from "./map"
import {
FieldType,
AutoFieldSubType,
FieldSubtype,
Row,
RowAttachment,
Table,
@ -159,10 +158,7 @@ export async function inputProcessing(
}
if (field.type === FieldType.BB_REFERENCE && value) {
clonedRow[key] = await processInputBBReferences(
value,
field.subtype as FieldSubtype
)
clonedRow[key] = await processInputBBReferences(value, field.subtype)
}
}
@ -238,7 +234,7 @@ export async function outputProcessing<T extends Row[] | Row>(
for (let row of enriched) {
row[property] = await processOutputBBReferences(
row[property],
column.subtype as FieldSubtype
column.subtype
)
}
}

50
packages/server/src/utilities/schema.ts
View File

@ -1,26 +1,14 @@
import { FieldType, FieldSubtype } from "@budibase/types"
import {
FieldType,
FieldSubtype,
TableSchema,
FieldSchema,
Row,
} from "@budibase/types"
import { ValidColumnNameRegex, utils } from "@budibase/shared-core"
import { db } from "@budibase/backend-core"
import { parseCsvExport } from "../api/controllers/view/exporters"
interface SchemaColumn {
readonly name: string
readonly type: FieldType
readonly subtype: FieldSubtype
readonly autocolumn?: boolean
readonly constraints?: {
presence: boolean
}
}
interface Schema {
readonly [index: string]: SchemaColumn
}
interface Row {
[index: string]: any
}
type Rows = Array<Row>
interface SchemaValidation {
@ -34,12 +22,10 @@ interface ValidationResults {
errors: Record<string, string>
}
export function isSchema(schema: any): schema is Schema {
export function isSchema(schema: any): schema is TableSchema {
return (
typeof schema === "object" &&
Object.values(schema).every(rawColumn => {
const column = rawColumn as SchemaColumn
Object.values<FieldSchema>(schema).every(column => {
return (
column !== null &&
typeof column === "object" &&
@ -54,7 +40,7 @@ export function isRows(rows: any): rows is Rows {
return Array.isArray(rows) && rows.every(row => typeof row === "object")
}
export function validate(rows: Rows, schema: Schema): ValidationResults {
export function validate(rows: Rows, schema: TableSchema): ValidationResults {
const results: ValidationResults = {
schemaValidation: {},
allValid: false,
@ -64,9 +50,11 @@ export function validate(rows: Rows, schema: Schema): ValidationResults {
rows.forEach(row => {
Object.entries(row).forEach(([columnName, columnData]) => {
const columnType = schema[columnName]?.type
const columnSubtype = schema[columnName]?.subtype
const isAutoColumn = schema[columnName]?.autocolumn
const {
type: columnType,
subtype: columnSubtype,
autocolumn: isAutoColumn,
} = schema[columnName]
// If the column had an invalid value we don't want to override it
if (results.schemaValidation[columnName] === false) {
@ -123,7 +111,7 @@ export function validate(rows: Rows, schema: Schema): ValidationResults {
return results
}
export function parse(rows: Rows, schema: Schema): Rows {
export function parse(rows: Rows, schema: TableSchema): Rows {
return rows.map(row => {
const parsedRow: Row = {}
@ -133,9 +121,7 @@ export function parse(rows: Rows, schema: Schema): Rows {
return
}
const columnType = schema[columnName].type
const columnSubtype = schema[columnName].subtype
const { type: columnType, subtype: columnSubtype } = schema[columnName]
if (columnType === FieldType.NUMBER) {
// If provided must be a valid number
parsedRow[columnName] = columnData ? Number(columnData) : columnData
@ -172,7 +158,7 @@ export function parse(rows: Rows, schema: Schema): Rows {
function isValidBBReference(
columnData: any,
columnSubtype: FieldSubtype
columnSubtype: FieldSubtype.USER | FieldSubtype.USERS
): boolean {
switch (columnSubtype) {
case FieldSubtype.USER:

2
packages/shared-core/tsconfig.json
View File

@ -1,6 +1,8 @@
{
"extends": "./tsconfig.build.json",
"compilerOptions": {
"baseUrl": "..",
"rootDir": "src",
"composite": true,
"types": ["node", "jest"]
},

39
packages/string-templates/src/helpers/list.ts
View File

@ -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<string, () => 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<any>(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, {})
}

9
packages/types/src/documents/app/row.ts
View File

@ -38,11 +38,16 @@ export interface Row extends Document {
export enum FieldSubtype {
USER = "user",
USERS = "users",
SINGLE = "single",
}
// The 'as' are required for typescript not to type the outputs as generic FieldSubtype
export const FieldTypeSubtypes = {
BB_REFERENCE: {
USER: FieldSubtype.USER,
USERS: FieldSubtype.USERS,
USER: FieldSubtype.USER as FieldSubtype.USER,
USERS: FieldSubtype.USERS as FieldSubtype.USERS,
},
ATTACHMENT: {
SINGLE: FieldSubtype.SINGLE as FieldSubtype.SINGLE,
},
}

16
packages/types/src/documents/app/table/schema.ts
View File

@ -112,6 +112,12 @@ export interface BBReferenceFieldMetadata
relationshipType?: RelationshipType
}
export interface AttachmentFieldMetadata
extends Omit<BaseFieldSchema, "subtype"> {
type: FieldType.ATTACHMENT
subtype?: FieldSubtype.SINGLE
}
export interface FieldConstraints {
type?: string
email?: boolean
@ -119,6 +125,7 @@ export interface FieldConstraints {
length?: {
minimum?: string | number | null
maximum?: string | number | null
message?: string
}
numericality?: {
greaterThanOrEqualTo: string | null
@ -156,6 +163,8 @@ interface OtherFieldMetadata extends BaseFieldSchema {
| FieldType.FORMULA
| FieldType.NUMBER
| FieldType.LONGFORM
| FieldType.BB_REFERENCE
| FieldType.ATTACHMENT
>
}
@ -169,6 +178,7 @@ export type FieldSchema =
| LongFormFieldMetadata
| BBReferenceFieldMetadata
| JsonFieldMetadata
| AttachmentFieldMetadata
export interface TableSchema {
[key: string]: FieldSchema
@ -203,3 +213,9 @@ export function isBBReferenceField(
): field is BBReferenceFieldMetadata {
return field.type === FieldType.BB_REFERENCE
}
export function isAttachmentField(
field: FieldSchema
): field is AttachmentFieldMetadata {
return field.type === FieldType.ATTACHMENT
}

2
qa-core/src/integrations/external-schema/mysql.integration.spec.ts
View File

@ -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

2
qa-core/src/integrations/validators/mysql.integration.spec.ts
View File

@ -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