From a24f5964aec756d7ff08838e280e511c22109461 Mon Sep 17 00:00:00 2001 From: Budibase Staging Release Bot <> Date: Thu, 11 Apr 2024 07:55:02 +0000 Subject: [PATCH 01/16] Bump version to 2.23.1 --- lerna.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lerna.json b/lerna.json index e5a2623766..da049a0e61 100644 --- a/lerna.json +++ b/lerna.json @@ -1,5 +1,5 @@ { - "version": "2.23.0", + "version": "2.23.1", "npmClient": "yarn", "packages": [ "packages/*", From 229bbc0d103f949f9e76522b88d4fc60a8fd05d5 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 09:53:54 +0100 Subject: [PATCH 02/16] Assert length on search tests, fixes bug in SQS around on empty return none. --- .../src/api/routes/tests/search.spec.ts | 59 ++++++++++--------- packages/server/src/integrations/base/sql.ts | 26 ++++++++ 2 files changed, 56 insertions(+), 29 deletions(-) diff --git a/packages/server/src/api/routes/tests/search.spec.ts b/packages/server/src/api/routes/tests/search.spec.ts index 96c3855f00..3fabbfbef9 100644 --- a/packages/server/src/api/routes/tests/search.spec.ts +++ b/packages/server/src/api/routes/tests/search.spec.ts @@ -6,6 +6,7 @@ import { Datasource, EmptyFilterOption, FieldType, + Row, SearchFilters, Table, } from "@budibase/types" @@ -47,7 +48,7 @@ describe.each([ }) describe("strings", () => { - beforeEach(async () => { + beforeAll(async () => { table = await config.api.table.save( tableForDatasource(datasource, { schema: { @@ -61,6 +62,13 @@ describe.each([ }) const rows = [{ name: "foo" }, { name: "bar" }] + let savedRows: Row[] + + beforeAll(async () => { + savedRows = await Promise.all( + rows.map(r => config.api.row.save(table._id!, r)) + ) + }) interface StringSearchTest { query: SearchFilters @@ -68,6 +76,8 @@ describe.each([ } const stringSearchTests: StringSearchTest[] = [ + // These three test cases are generic and don't really need + // to be repeated for all data types, so we just do them here. { query: {}, expected: rows }, { query: { onEmptyFilter: EmptyFilterOption.RETURN_ALL }, @@ -77,6 +87,7 @@ describe.each([ query: { onEmptyFilter: EmptyFilterOption.RETURN_NONE }, expected: [], }, + // The rest of these tests are specific to strings. { query: { string: { name: "foo" } }, expected: [rows[0]] }, { query: { string: { name: "none" } }, expected: [] }, { query: { fuzzy: { name: "oo" } }, expected: [rows[0]] }, @@ -88,13 +99,11 @@ describe.each([ it.each(stringSearchTests)( `should be able to run query: $query`, async ({ query, expected }) => { - const savedRows = await Promise.all( - rows.map(r => config.api.row.save(table._id!, r)) - ) const { rows: foundRows } = await config.api.row.search(table._id!, { tableId: table._id!, query, }) + expect(foundRows).toHaveLength(expected.length) expect(foundRows).toEqual( expect.arrayContaining( expected.map(r => @@ -107,7 +116,7 @@ describe.each([ }) describe("number", () => { - beforeEach(async () => { + beforeAll(async () => { table = await config.api.table.save( tableForDatasource(datasource, { schema: { @@ -121,6 +130,13 @@ describe.each([ }) const rows = [{ age: 1 }, { age: 10 }] + let savedRows: Row[] + + beforeAll(async () => { + savedRows = await Promise.all( + rows.map(r => config.api.row.save(table._id!, r)) + ) + }) interface NumberSearchTest { query: SearchFilters @@ -128,15 +144,6 @@ describe.each([ } const numberSearchTests: NumberSearchTest[] = [ - { query: {}, expected: rows }, - { - query: { onEmptyFilter: EmptyFilterOption.RETURN_ALL }, - expected: rows, - }, - { - query: { onEmptyFilter: EmptyFilterOption.RETURN_NONE }, - expected: [], - }, { query: { equal: { age: 1 } }, expected: [rows[0]] }, { query: { equal: { age: 2 } }, expected: [] }, { query: { notEqual: { age: 1 } }, expected: [rows[1]] }, @@ -150,13 +157,11 @@ describe.each([ it.each(numberSearchTests)( `should be able to run query: $query`, async ({ query, expected }) => { - const savedRows = await Promise.all( - rows.map(r => config.api.row.save(table._id!, r)) - ) const { rows: foundRows } = await config.api.row.search(table._id!, { tableId: table._id!, query, }) + expect(foundRows).toHaveLength(expected.length) expect(foundRows).toEqual( expect.arrayContaining( expected.map(r => @@ -186,6 +191,13 @@ describe.each([ { dob: new Date("2020-01-01").toISOString() }, { dob: new Date("2020-01-10").toISOString() }, ] + let savedRows: Row[] + + beforeEach(async () => { + savedRows = await Promise.all( + rows.map(r => config.api.row.save(table._id!, r)) + ) + }) interface DateSearchTest { query: SearchFilters @@ -193,15 +205,6 @@ describe.each([ } const dateSearchTests: DateSearchTest[] = [ - { query: {}, expected: rows }, - { - query: { onEmptyFilter: EmptyFilterOption.RETURN_ALL }, - expected: rows, - }, - { - query: { onEmptyFilter: EmptyFilterOption.RETURN_NONE }, - expected: [], - }, { query: { equal: { dob: new Date("2020-01-01").toISOString() } }, expected: [rows[0]], @@ -256,13 +259,11 @@ describe.each([ it.each(dateSearchTests)( `should be able to run query: $query`, async ({ query, expected }) => { - const savedRows = await Promise.all( - rows.map(r => config.api.row.save(table._id!, r)) - ) const { rows: foundRows } = await config.api.row.search(table._id!, { tableId: table._id!, query, }) + expect(foundRows).toHaveLength(expected.length) expect(foundRows).toEqual( expect.arrayContaining( expected.map(r => diff --git a/packages/server/src/integrations/base/sql.ts b/packages/server/src/integrations/base/sql.ts index e99e34ab0f..abf12b35b2 100644 --- a/packages/server/src/integrations/base/sql.ts +++ b/packages/server/src/integrations/base/sql.ts @@ -22,6 +22,7 @@ import { SortDirection, SqlQueryBinding, Table, + EmptyFilterOption, } from "@budibase/types" import environment from "../../environment" @@ -243,6 +244,7 @@ class InternalBuilder { return query } filters = parseFilters(filters) + let noFilters = true // if all or specified in filters, then everything is an or const allOr = filters.allOr if (filters.oneOf) { @@ -250,6 +252,7 @@ class InternalBuilder { const fnc = allOr ? "orWhereIn" : "whereIn" query = query[fnc](key, Array.isArray(array) ? array : [array]) }) + noFilters = false } if (filters.string) { iterate(filters.string, (key, value) => { @@ -265,9 +268,11 @@ class InternalBuilder { ]) } }) + noFilters = false } if (filters.fuzzy) { iterate(filters.fuzzy, like) + noFilters = false } if (filters.range) { iterate(filters.range, (key, value) => { @@ -300,40 +305,61 @@ class InternalBuilder { query = query[fnc](key, "<", value.high) } }) + noFilters = false } if (filters.equal) { iterate(filters.equal, (key, value) => { const fnc = allOr ? "orWhere" : "where" query = query[fnc]({ [key]: value }) }) + + // Somewhere above us in the stack adds `{ type: "row" }` to the `equal` + // key before we get here, so we need to still consider it empty when + // that's the case. + const equalEmpty = + Object.keys(filters.equal).length === 1 && filters.equal.type === "row" + if (!equalEmpty) { + noFilters = false + } } if (filters.notEqual) { iterate(filters.notEqual, (key, value) => { const fnc = allOr ? "orWhereNot" : "whereNot" query = query[fnc]({ [key]: value }) }) + noFilters = false } if (filters.empty) { iterate(filters.empty, key => { const fnc = allOr ? "orWhereNull" : "whereNull" query = query[fnc](key) }) + noFilters = false } if (filters.notEmpty) { iterate(filters.notEmpty, key => { const fnc = allOr ? "orWhereNotNull" : "whereNotNull" query = query[fnc](key) }) + noFilters = false } if (filters.contains) { contains(filters.contains) + noFilters = false } if (filters.notContains) { contains(filters.notContains) + noFilters = false } if (filters.containsAny) { contains(filters.containsAny, true) + noFilters = false } + + if (noFilters && filters.onEmptyFilter === EmptyFilterOption.RETURN_NONE) { + query = query.whereRaw("1=0") + } + return query } From 187e7b281a05a852bb1992046454ca58321a5306 Mon Sep 17 00:00:00 2001 From: melohagan <101575380+melohagan@users.noreply.github.com> Date: Thu, 11 Apr 2024 09:57:36 +0100 Subject: [PATCH 03/16] Chore/update csp posthog (#13455) * Add us.i.posthog.com to CSP * Allow posthog survey scripts in CSP --- hosting/proxy/nginx.prod.conf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hosting/proxy/nginx.prod.conf b/hosting/proxy/nginx.prod.conf index 5b31d86fe3..79007da311 100644 --- a/hosting/proxy/nginx.prod.conf +++ b/hosting/proxy/nginx.prod.conf @@ -51,7 +51,7 @@ http { proxy_buffering off; set $csp_default "default-src 'self'"; - set $csp_script "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://*.budibase.net https://cdn.budi.live https://js.intercomcdn.com https://widget.intercom.io https://d2l5prqdbvm3op.cloudfront.net"; + set $csp_script "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://*.budibase.net https://cdn.budi.live https://js.intercomcdn.com https://widget.intercom.io https://d2l5prqdbvm3op.cloudfront.net https://us-assets.i.posthog.com"; set $csp_style "style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://fonts.googleapis.com https://rsms.me https://maxcdn.bootstrapcdn.com"; set $csp_object "object-src 'none'"; set $csp_base_uri "base-uri 'self'"; From ad913929af5dff13cc3002f33f928b3fe6f2ab7d Mon Sep 17 00:00:00 2001 From: Budibase Staging Release Bot <> Date: Thu, 11 Apr 2024 08:58:10 +0000 Subject: [PATCH 04/16] Bump version to 2.23.2 --- lerna.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lerna.json b/lerna.json index da049a0e61..f7ed11cebd 100644 --- a/lerna.json +++ b/lerna.json @@ -1,5 +1,5 @@ { - "version": "2.23.1", + "version": "2.23.2", "npmClient": "yarn", "packages": [ "packages/*", From 672025e17602d94dde9bb48e8e13a64f45195965 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 10:11:03 +0100 Subject: [PATCH 05/16] Solve onEmptyFilter in a nicer way. --- .../src/api/controllers/row/external.ts | 13 ---------- packages/server/src/integrations/base/sql.ts | 25 ------------------- packages/server/src/sdk/app/rows/search.ts | 12 +++++++++ 3 files changed, 12 insertions(+), 38 deletions(-) diff --git a/packages/server/src/api/controllers/row/external.ts b/packages/server/src/api/controllers/row/external.ts index 8ce9ff0f9d..e0e3cb6c18 100644 --- a/packages/server/src/api/controllers/row/external.ts +++ b/packages/server/src/api/controllers/row/external.ts @@ -17,11 +17,9 @@ import { Row, Table, UserCtx, - EmptyFilterOption, } from "@budibase/types" import sdk from "../../../sdk" import * as utils from "./utils" -import { dataFilters } from "@budibase/shared-core" import { inputProcessing, outputProcessing, @@ -33,17 +31,6 @@ export async function handleRequest( tableId: string, opts?: RunConfig ): Promise> { - // make sure the filters are cleaned up, no empty strings for equals, fuzzy or string - if (opts && opts.filters) { - opts.filters = sdk.rows.removeEmptyFilters(opts.filters) - } - if ( - !dataFilters.hasFilters(opts?.filters) && - opts?.filters?.onEmptyFilter === EmptyFilterOption.RETURN_NONE - ) { - return [] as any - } - return new ExternalRequest(operation, tableId, opts?.datasource).run( opts || {} ) diff --git a/packages/server/src/integrations/base/sql.ts b/packages/server/src/integrations/base/sql.ts index abf12b35b2..f5828f9419 100644 --- a/packages/server/src/integrations/base/sql.ts +++ b/packages/server/src/integrations/base/sql.ts @@ -22,7 +22,6 @@ import { SortDirection, SqlQueryBinding, Table, - EmptyFilterOption, } from "@budibase/types" import environment from "../../environment" @@ -244,7 +243,6 @@ class InternalBuilder { return query } filters = parseFilters(filters) - let noFilters = true // if all or specified in filters, then everything is an or const allOr = filters.allOr if (filters.oneOf) { @@ -252,7 +250,6 @@ class InternalBuilder { const fnc = allOr ? "orWhereIn" : "whereIn" query = query[fnc](key, Array.isArray(array) ? array : [array]) }) - noFilters = false } if (filters.string) { iterate(filters.string, (key, value) => { @@ -268,11 +265,9 @@ class InternalBuilder { ]) } }) - noFilters = false } if (filters.fuzzy) { iterate(filters.fuzzy, like) - noFilters = false } if (filters.range) { iterate(filters.range, (key, value) => { @@ -305,59 +300,39 @@ class InternalBuilder { query = query[fnc](key, "<", value.high) } }) - noFilters = false } if (filters.equal) { iterate(filters.equal, (key, value) => { const fnc = allOr ? "orWhere" : "where" query = query[fnc]({ [key]: value }) }) - - // Somewhere above us in the stack adds `{ type: "row" }` to the `equal` - // key before we get here, so we need to still consider it empty when - // that's the case. - const equalEmpty = - Object.keys(filters.equal).length === 1 && filters.equal.type === "row" - if (!equalEmpty) { - noFilters = false - } } if (filters.notEqual) { iterate(filters.notEqual, (key, value) => { const fnc = allOr ? "orWhereNot" : "whereNot" query = query[fnc]({ [key]: value }) }) - noFilters = false } if (filters.empty) { iterate(filters.empty, key => { const fnc = allOr ? "orWhereNull" : "whereNull" query = query[fnc](key) }) - noFilters = false } if (filters.notEmpty) { iterate(filters.notEmpty, key => { const fnc = allOr ? "orWhereNotNull" : "whereNotNull" query = query[fnc](key) }) - noFilters = false } if (filters.contains) { contains(filters.contains) - noFilters = false } if (filters.notContains) { contains(filters.notContains) - noFilters = false } if (filters.containsAny) { contains(filters.containsAny, true) - noFilters = false - } - - if (noFilters && filters.onEmptyFilter === EmptyFilterOption.RETURN_NONE) { - query = query.whereRaw("1=0") } return query diff --git a/packages/server/src/sdk/app/rows/search.ts b/packages/server/src/sdk/app/rows/search.ts index 928c0f6780..65fd19e427 100644 --- a/packages/server/src/sdk/app/rows/search.ts +++ b/packages/server/src/sdk/app/rows/search.ts @@ -1,4 +1,5 @@ import { + EmptyFilterOption, Row, RowSearchParams, SearchFilters, @@ -11,6 +12,7 @@ import { NoEmptyFilterStrings } from "../../../constants" import * as sqs from "./search/sqs" import env from "../../../environment" import { ExportRowsParams, ExportRowsResult } from "./search/types" +import { dataFilters } from "@budibase/shared-core" export { isValidFilter } from "../../../integrations/utils" @@ -60,6 +62,16 @@ export async function search( options: RowSearchParams ): Promise> { const isExternalTable = isExternalTableID(options.tableId) + options.query = removeEmptyFilters(options.query) + if ( + !dataFilters.hasFilters(options.query) && + options.query.onEmptyFilter === EmptyFilterOption.RETURN_NONE + ) { + return { + rows: [], + } + } + if (isExternalTable) { return external.search(options) } else if (env.SQS_SEARCH_ENABLE) { From 5a36422b97784808d21d6b5f90c77146c41c49e6 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 10:21:30 +0100 Subject: [PATCH 06/16] Fix postgres tests. --- packages/server/src/sdk/app/rows/search.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/server/src/sdk/app/rows/search.ts b/packages/server/src/sdk/app/rows/search.ts index 65fd19e427..f681bfeb90 100644 --- a/packages/server/src/sdk/app/rows/search.ts +++ b/packages/server/src/sdk/app/rows/search.ts @@ -62,7 +62,7 @@ export async function search( options: RowSearchParams ): Promise> { const isExternalTable = isExternalTableID(options.tableId) - options.query = removeEmptyFilters(options.query) + options.query = removeEmptyFilters(options.query || {}) if ( !dataFilters.hasFilters(options.query) && options.query.onEmptyFilter === EmptyFilterOption.RETURN_NONE From ba171bb5a229c9e089484ef8926c6a04245bd410 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 11:58:21 +0100 Subject: [PATCH 07/16] Reduce duplication in search.spec.ts --- .../src/api/routes/tests/search.spec.ts | 292 +++++++++--------- 1 file changed, 144 insertions(+), 148 deletions(-) diff --git a/packages/server/src/api/routes/tests/search.spec.ts b/packages/server/src/api/routes/tests/search.spec.ts index 3fabbfbef9..5be65553e4 100644 --- a/packages/server/src/api/routes/tests/search.spec.ts +++ b/packages/server/src/api/routes/tests/search.spec.ts @@ -6,11 +6,18 @@ import { Datasource, EmptyFilterOption, FieldType, - Row, - SearchFilters, + RowSearchParams, + SortOrder, Table, } from "@budibase/types" +function leftContainsRight< + A extends Record, + B extends Record +>(left: A, right: B) { + return Object.entries(right).every(([k, v]) => left[k] === v) +} + jest.unmock("mssql") describe.each([ @@ -47,10 +54,79 @@ describe.each([ } }) - describe("strings", () => { - beforeAll(async () => { - table = await config.api.table.save( - tableForDatasource(datasource, { + async function testSearch>( + test: SearchTest, + table: Table + ) { + const expected = test.expectToFind + delete test.expectToFind + const { rows: foundRows } = await config.api.row.search(table._id!, { + ...test, + tableId: table._id!, + }) + if (!expected) { + return + } + expect(foundRows).toHaveLength(expected.length) + expect(foundRows).toEqual( + expect.arrayContaining( + expected.map(expectedRow => + expect.objectContaining( + foundRows.find(foundRow => leftContainsRight(foundRow, expectedRow)) + ) + ) + ) + ) + } + + function searchTests>( + name: string, + opts: { + table: (ds?: Datasource) => Promise + rows: T[] + tests: SearchTest[] + } + ) { + let table: Table + + for (const test of opts.tests) { + test.toString = () => { + const queryStr = JSON.stringify({ + query: test.query, + limit: test.limit, + sort: test.sort, + sortOrder: test.sortOrder, + }) + const expectStr = JSON.stringify(test.expectToFind) + return `should run: ${queryStr} and find ${expectStr}` + } + } + + // eslint-disable-next-line jest/valid-title + describe(name, () => { + beforeAll(async () => { + table = await opts.table(datasource) + }) + + beforeAll(async () => { + await Promise.all( + opts.rows.map(r => config.api.row.save(table._id!, r)) + ) + }) + + it.each(opts.tests)(`%s`, test => testSearch(test, table)) + }) + } + + interface SearchTest> + extends Omit { + expectToFind?: RowType[] + } + + searchTests("strings", { + table: async ds => { + return await config.api.table.save( + tableForDatasource(ds, { schema: { name: { name: "name", @@ -59,66 +135,38 @@ describe.each([ }, }) ) - }) + }, + rows: [{ name: "foo" }, { name: "bar" }], + tests: [ + // These test cases are generic and don't really need to be repeated for + // all data types, so we just do them here. - const rows = [{ name: "foo" }, { name: "bar" }] - let savedRows: Row[] - - beforeAll(async () => { - savedRows = await Promise.all( - rows.map(r => config.api.row.save(table._id!, r)) - ) - }) - - interface StringSearchTest { - query: SearchFilters - expected: (typeof rows)[number][] - } - - const stringSearchTests: StringSearchTest[] = [ - // These three test cases are generic and don't really need - // to be repeated for all data types, so we just do them here. - { query: {}, expected: rows }, + // @ts-expect-error - intentionally not passing a query to make sure the + // API can handle it. + { expectToFind: [{ name: "foo" }, { name: "bar" }] }, + { query: {}, expectToFind: [{ name: "foo" }, { name: "bar" }] }, { query: { onEmptyFilter: EmptyFilterOption.RETURN_ALL }, - expected: rows, + expectToFind: [{ name: "foo" }, { name: "bar" }], }, { query: { onEmptyFilter: EmptyFilterOption.RETURN_NONE }, - expected: [], + expectToFind: [], }, // The rest of these tests are specific to strings. - { query: { string: { name: "foo" } }, expected: [rows[0]] }, - { query: { string: { name: "none" } }, expected: [] }, - { query: { fuzzy: { name: "oo" } }, expected: [rows[0]] }, - { query: { equal: { name: "foo" } }, expected: [rows[0]] }, - { query: { notEqual: { name: "foo" } }, expected: [rows[1]] }, - { query: { oneOf: { name: ["foo"] } }, expected: [rows[0]] }, - ] - - it.each(stringSearchTests)( - `should be able to run query: $query`, - async ({ query, expected }) => { - const { rows: foundRows } = await config.api.row.search(table._id!, { - tableId: table._id!, - query, - }) - expect(foundRows).toHaveLength(expected.length) - expect(foundRows).toEqual( - expect.arrayContaining( - expected.map(r => - expect.objectContaining(savedRows.find(sr => sr.name === r.name)!) - ) - ) - ) - } - ) + { query: { string: { name: "foo" } }, expectToFind: [{ name: "foo" }] }, + { query: { string: { name: "none" } }, expectToFind: [] }, + { query: { fuzzy: { name: "oo" } }, expectToFind: [{ name: "foo" }] }, + { query: { equal: { name: "foo" } }, expectToFind: [{ name: "foo" }] }, + { query: { notEqual: { name: "foo" } }, expectToFind: [{ name: "bar" }] }, + { query: { oneOf: { name: ["foo"] } }, expectToFind: [{ name: "foo" }] }, + ], }) - describe("number", () => { - beforeAll(async () => { - table = await config.api.table.save( - tableForDatasource(datasource, { + searchTests("numbers", { + table: async ds => { + return await config.api.table.save( + tableForDatasource(ds, { schema: { age: { name: "age", @@ -127,56 +175,33 @@ describe.each([ }, }) ) - }) - - const rows = [{ age: 1 }, { age: 10 }] - let savedRows: Row[] - - beforeAll(async () => { - savedRows = await Promise.all( - rows.map(r => config.api.row.save(table._id!, r)) - ) - }) - - interface NumberSearchTest { - query: SearchFilters - expected: (typeof rows)[number][] - } - - const numberSearchTests: NumberSearchTest[] = [ - { query: { equal: { age: 1 } }, expected: [rows[0]] }, - { query: { equal: { age: 2 } }, expected: [] }, - { query: { notEqual: { age: 1 } }, expected: [rows[1]] }, - { query: { oneOf: { age: [1] } }, expected: [rows[0]] }, - { query: { range: { age: { low: 1, high: 5 } } }, expected: [rows[0]] }, - { query: { range: { age: { low: 0, high: 1 } } }, expected: [rows[0]] }, - { query: { range: { age: { low: 3, high: 4 } } }, expected: [] }, - { query: { range: { age: { low: 0, high: 11 } } }, expected: rows }, - ] - - it.each(numberSearchTests)( - `should be able to run query: $query`, - async ({ query, expected }) => { - const { rows: foundRows } = await config.api.row.search(table._id!, { - tableId: table._id!, - query, - }) - expect(foundRows).toHaveLength(expected.length) - expect(foundRows).toEqual( - expect.arrayContaining( - expected.map(r => - expect.objectContaining(savedRows.find(sr => sr.age === r.age)!) - ) - ) - ) - } - ) + }, + rows: [{ age: 1 }, { age: 10 }], + tests: [ + { query: { equal: { age: 1 } }, expectToFind: [{ age: 1 }] }, + { query: { equal: { age: 2 } }, expectToFind: [] }, + { query: { notEqual: { age: 1 } }, expectToFind: [{ age: 10 }] }, + { query: { oneOf: { age: [1] } }, expectToFind: [{ age: 1 }] }, + { + query: { range: { age: { low: 1, high: 5 } } }, + expectToFind: [{ age: 1 }], + }, + { + query: { range: { age: { low: 0, high: 1 } } }, + expectToFind: [{ age: 1 }], + }, + { query: { range: { age: { low: 3, high: 4 } } }, expectToFind: [] }, + { + query: { range: { age: { low: 0, high: 11 } } }, + expectToFind: [{ age: 1 }, { age: 10 }], + }, + ], }) - describe("dates", () => { - beforeEach(async () => { - table = await config.api.table.save( - tableForDatasource(datasource, { + searchTests("dates", { + table: async ds => { + return await config.api.table.save( + tableForDatasource(ds, { schema: { dob: { name: "dob", @@ -185,41 +210,27 @@ describe.each([ }, }) ) - }) - - const rows = [ + }, + rows: [ { dob: new Date("2020-01-01").toISOString() }, { dob: new Date("2020-01-10").toISOString() }, - ] - let savedRows: Row[] - - beforeEach(async () => { - savedRows = await Promise.all( - rows.map(r => config.api.row.save(table._id!, r)) - ) - }) - - interface DateSearchTest { - query: SearchFilters - expected: (typeof rows)[number][] - } - - const dateSearchTests: DateSearchTest[] = [ + ], + tests: [ { query: { equal: { dob: new Date("2020-01-01").toISOString() } }, - expected: [rows[0]], + expectToFind: [{ dob: new Date("2020-01-01").toISOString() }], }, { query: { equal: { dob: new Date("2020-01-02").toISOString() } }, - expected: [], + expectToFind: [], }, { query: { notEqual: { dob: new Date("2020-01-01").toISOString() } }, - expected: [rows[1]], + expectToFind: [{ dob: new Date("2020-01-10").toISOString() }], }, { query: { oneOf: { dob: [new Date("2020-01-01").toISOString()] } }, - expected: [rows[0]], + expectToFind: [{ dob: new Date("2020-01-01").toISOString() }], }, { query: { @@ -230,7 +241,7 @@ describe.each([ }, }, }, - expected: [rows[0]], + expectToFind: [{ dob: new Date("2020-01-01").toISOString() }], }, { query: { @@ -241,7 +252,10 @@ describe.each([ }, }, }, - expected: rows, + expectToFind: [ + { dob: new Date("2020-01-01").toISOString() }, + { dob: new Date("2020-01-10").toISOString() }, + ], }, { query: { @@ -252,26 +266,8 @@ describe.each([ }, }, }, - expected: [rows[1]], + expectToFind: [{ dob: new Date("2020-01-10").toISOString() }], }, - ] - - it.each(dateSearchTests)( - `should be able to run query: $query`, - async ({ query, expected }) => { - const { rows: foundRows } = await config.api.row.search(table._id!, { - tableId: table._id!, - query, - }) - expect(foundRows).toHaveLength(expected.length) - expect(foundRows).toEqual( - expect.arrayContaining( - expected.map(r => - expect.objectContaining(savedRows.find(sr => sr.dob === r.dob)!) - ) - ) - ) - } - ) + ], }) }) From 0d564a8b4cd025415b4e0f8ca25c409f81e0d373 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 11:58:49 +0100 Subject: [PATCH 08/16] Remove unused variables. --- packages/server/src/api/routes/tests/search.spec.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/packages/server/src/api/routes/tests/search.spec.ts b/packages/server/src/api/routes/tests/search.spec.ts index 5be65553e4..79399a9272 100644 --- a/packages/server/src/api/routes/tests/search.spec.ts +++ b/packages/server/src/api/routes/tests/search.spec.ts @@ -7,7 +7,6 @@ import { EmptyFilterOption, FieldType, RowSearchParams, - SortOrder, Table, } from "@budibase/types" @@ -32,7 +31,6 @@ describe.each([ const config = setup.getConfig() let envCleanup: (() => void) | undefined - let table: Table let datasource: Datasource | undefined beforeAll(async () => { From eb56140ce25e7ad7cb36bbb301c0c8dae03d0e2a Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 12:03:34 +0100 Subject: [PATCH 09/16] Convert dates to strings, looks nicer and makes no difference. --- .../src/api/routes/tests/search.spec.ts | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/packages/server/src/api/routes/tests/search.spec.ts b/packages/server/src/api/routes/tests/search.spec.ts index 79399a9272..a99df1a744 100644 --- a/packages/server/src/api/routes/tests/search.spec.ts +++ b/packages/server/src/api/routes/tests/search.spec.ts @@ -210,61 +210,61 @@ describe.each([ ) }, rows: [ - { dob: new Date("2020-01-01").toISOString() }, - { dob: new Date("2020-01-10").toISOString() }, + { dob: "2020-01-01T00:00:00.000Z" }, + { dob: "2020-01-10T00:00:00.000Z" }, ], tests: [ { - query: { equal: { dob: new Date("2020-01-01").toISOString() } }, - expectToFind: [{ dob: new Date("2020-01-01").toISOString() }], + query: { equal: { dob: "2020-01-01T00:00:00.000Z" } }, + expectToFind: [{ dob: "2020-01-01T00:00:00.000Z" }], }, { - query: { equal: { dob: new Date("2020-01-02").toISOString() } }, + query: { equal: { dob: "2020-01-02T00:00:00.000Z" } }, expectToFind: [], }, { - query: { notEqual: { dob: new Date("2020-01-01").toISOString() } }, - expectToFind: [{ dob: new Date("2020-01-10").toISOString() }], + query: { notEqual: { dob: "2020-01-01T00:00:00.000Z" } }, + expectToFind: [{ dob: "2020-01-10T00:00:00.000Z" }], }, { - query: { oneOf: { dob: [new Date("2020-01-01").toISOString()] } }, - expectToFind: [{ dob: new Date("2020-01-01").toISOString() }], + query: { oneOf: { dob: ["2020-01-01T00:00:00.000Z"] } }, + expectToFind: [{ dob: "2020-01-01T00:00:00.000Z" }], }, { query: { range: { dob: { - low: new Date("2020-01-01").toISOString(), - high: new Date("2020-01-05").toISOString(), + low: "2020-01-01T00:00:00.000Z", + high: "2020-01-05T00:00:00.000Z", }, }, }, - expectToFind: [{ dob: new Date("2020-01-01").toISOString() }], + expectToFind: [{ dob: "2020-01-01T00:00:00.000Z" }], }, { query: { range: { dob: { - low: new Date("2020-01-01").toISOString(), - high: new Date("2020-01-10").toISOString(), + low: "2020-01-01T00:00:00.000Z", + high: "2020-01-10T00:00:00.000Z", }, }, }, expectToFind: [ - { dob: new Date("2020-01-01").toISOString() }, - { dob: new Date("2020-01-10").toISOString() }, + { dob: "2020-01-01T00:00:00.000Z" }, + { dob: "2020-01-10T00:00:00.000Z" }, ], }, { query: { range: { dob: { - low: new Date("2020-01-05").toISOString(), - high: new Date("2020-01-10").toISOString(), + low: "2020-01-05T00:00:00.000Z", + high: "2020-01-10T00:00:00.000Z", }, }, }, - expectToFind: [{ dob: new Date("2020-01-10").toISOString() }], + expectToFind: [{ dob: "2020-01-10T00:00:00.000Z" }], }, ], }) From 8c32127a6f247fd1258720c59d3eb03efda4eb7e Mon Sep 17 00:00:00 2001 From: Budibase Staging Release Bot <> Date: Thu, 11 Apr 2024 11:15:05 +0000 Subject: [PATCH 10/16] Bump version to 2.23.3 --- lerna.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lerna.json b/lerna.json index f7ed11cebd..385d86209a 100644 --- a/lerna.json +++ b/lerna.json @@ -1,5 +1,5 @@ { - "version": "2.23.2", + "version": "2.23.3", "npmClient": "yarn", "packages": [ "packages/*", From c07882b4526899912ec31787e496c1c06fc03872 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Thu, 11 Apr 2024 15:16:26 +0100 Subject: [PATCH 11/16] Restructure search.spec.ts to be much more readable. --- .../src/api/routes/tests/search.spec.ts | 406 +++++++++--------- 1 file changed, 200 insertions(+), 206 deletions(-) diff --git a/packages/server/src/api/routes/tests/search.spec.ts b/packages/server/src/api/routes/tests/search.spec.ts index a99df1a744..fdf1ed7603 100644 --- a/packages/server/src/api/routes/tests/search.spec.ts +++ b/packages/server/src/api/routes/tests/search.spec.ts @@ -7,15 +7,11 @@ import { EmptyFilterOption, FieldType, RowSearchParams, + SearchFilters, Table, + TableSchema, } from "@budibase/types" - -function leftContainsRight< - A extends Record, - B extends Record ->(left: A, right: B) { - return Object.entries(right).every(([k, v]) => left[k] === v) -} +import _ from "lodash" jest.unmock("mssql") @@ -32,6 +28,7 @@ describe.each([ let envCleanup: (() => void) | undefined let datasource: Datasource | undefined + let table: Table beforeAll(async () => { if (isSqs) { @@ -52,220 +49,217 @@ describe.each([ } }) - async function testSearch>( - test: SearchTest, - table: Table - ) { - const expected = test.expectToFind - delete test.expectToFind - const { rows: foundRows } = await config.api.row.search(table._id!, { - ...test, - tableId: table._id!, - }) - if (!expected) { - return - } - expect(foundRows).toHaveLength(expected.length) - expect(foundRows).toEqual( - expect.arrayContaining( - expected.map(expectedRow => - expect.objectContaining( - foundRows.find(foundRow => leftContainsRight(foundRow, expectedRow)) - ) - ) - ) + async function createTable(schema: TableSchema) { + table = await config.api.table.save( + tableForDatasource(datasource, { schema }) ) } - function searchTests>( - name: string, - opts: { - table: (ds?: Datasource) => Promise
- rows: T[] - tests: SearchTest[] - } - ) { - let table: Table + async function createRows(rows: Record[]) { + await Promise.all(rows.map(r => config.api.row.save(table._id!, r))) + } - for (const test of opts.tests) { - test.toString = () => { - const queryStr = JSON.stringify({ - query: test.query, - limit: test.limit, - sort: test.sort, - sortOrder: test.sortOrder, - }) - const expectStr = JSON.stringify(test.expectToFind) - return `should run: ${queryStr} and find ${expectStr}` - } - } + class SearchAssertion { + constructor(private readonly query: RowSearchParams) {} - // eslint-disable-next-line jest/valid-title - describe(name, () => { - beforeAll(async () => { - table = await opts.table(datasource) + async toFind(expectedRows: any[]) { + const { rows: foundRows } = await config.api.row.search(table._id!, { + ...this.query, + tableId: table._id!, }) - beforeAll(async () => { - await Promise.all( - opts.rows.map(r => config.api.row.save(table._id!, r)) + // eslint-disable-next-line jest/no-standalone-expect + expect(foundRows).toHaveLength(expectedRows.length) + // eslint-disable-next-line jest/no-standalone-expect + expect(foundRows).toEqual( + expect.arrayContaining( + expectedRows.map((expectedRow: any) => + expect.objectContaining( + foundRows.find(foundRow => _.isMatch(foundRow, expectedRow)) + ) + ) ) + ) + } + + async toFindNothing() { + await this.toFind([]) + } + } + + function expectSearch(query: Omit) { + return new SearchAssertion({ ...query, tableId: table._id! }) + } + + function expectQuery(query: SearchFilters) { + return expectSearch({ query }) + } + + describe("strings", () => { + beforeAll(async () => { + await createTable({ + name: { name: "name", type: FieldType.STRING }, + }) + await createRows([{ name: "foo" }, { name: "bar" }]) + }) + + describe("misc", () => { + it("should return all if no query is passed", () => + expectSearch({} as RowSearchParams).toFind([ + { name: "foo" }, + { name: "bar" }, + ])) + + it("should return all if empty query is passed", () => + expectQuery({}).toFind([{ name: "foo" }, { name: "bar" }])) + + it("should return all if onEmptyFilter is RETURN_ALL", () => + expectQuery({ + onEmptyFilter: EmptyFilterOption.RETURN_ALL, + }).toFind([{ name: "foo" }, { name: "bar" }])) + + it("should return nothing if onEmptyFilter is RETURN_NONE", () => + expectQuery({ + onEmptyFilter: EmptyFilterOption.RETURN_NONE, + }).toFindNothing()) + }) + + describe("equal", () => { + it("successfully finds a row", () => + expectQuery({ equal: { name: "foo" } }).toFind([{ name: "foo" }])) + + it("fails to find nonexistent row", () => + expectQuery({ equal: { name: "none" } }).toFindNothing()) + }) + + describe("notEqual", () => { + it("successfully finds a row", () => + expectQuery({ notEqual: { name: "foo" } }).toFind([{ name: "bar" }])) + + it("fails to find nonexistent row", () => + expectQuery({ notEqual: { name: "bar" } }).toFind([{ name: "foo" }])) + }) + + describe("oneOf", () => { + it("successfully finds a row", () => + expectQuery({ oneOf: { name: ["foo"] } }).toFind([{ name: "foo" }])) + + it("fails to find nonexistent row", () => + expectQuery({ oneOf: { name: ["none"] } }).toFindNothing()) + }) + + describe("fuzzy", () => { + it("successfully finds a row", () => + expectQuery({ fuzzy: { name: "oo" } }).toFind([{ name: "foo" }])) + + it("fails to find nonexistent row", () => + expectQuery({ fuzzy: { name: "none" } }).toFindNothing()) + }) + }) + + describe("numbers", () => { + beforeAll(async () => { + await createTable({ + age: { name: "age", type: FieldType.NUMBER }, + }) + await createRows([{ age: 1 }, { age: 10 }]) + }) + + describe("equal", () => { + it("successfully finds a row", () => + expectQuery({ equal: { age: 1 } }).toFind([{ age: 1 }])) + + it("fails to find nonexistent row", () => + expectQuery({ equal: { age: 2 } }).toFindNothing()) + }) + + describe("notEqual", () => { + it("successfully finds a row", () => + expectQuery({ notEqual: { age: 1 } }).toFind([{ age: 10 }])) + + it("fails to find nonexistent row", () => + expectQuery({ notEqual: { age: 10 } }).toFind([{ age: 1 }])) + }) + + describe("oneOf", () => { + it("successfully finds a row", () => + expectQuery({ oneOf: { age: [1] } }).toFind([{ age: 1 }])) + + it("fails to find nonexistent row", () => + expectQuery({ oneOf: { age: [2] } }).toFindNothing()) + }) + + describe("range", () => { + it("successfully finds a row", () => + expectQuery({ + range: { age: { low: 1, high: 5 } }, + }).toFind([{ age: 1 }])) + + it("successfully finds multiple rows", () => + expectQuery({ + range: { age: { low: 1, high: 10 } }, + }).toFind([{ age: 1 }, { age: 10 }])) + + it("successfully finds a row with a high bound", () => + expectQuery({ + range: { age: { low: 5, high: 10 } }, + }).toFind([{ age: 10 }])) + }) + }) + + describe("dates", () => { + const JAN_1ST = "2020-01-01T00:00:00.000Z" + const JAN_2ND = "2020-01-02T00:00:00.000Z" + const JAN_5TH = "2020-01-05T00:00:00.000Z" + const JAN_10TH = "2020-01-10T00:00:00.000Z" + + beforeAll(async () => { + await createTable({ + dob: { name: "dob", type: FieldType.DATETIME }, }) - it.each(opts.tests)(`%s`, test => testSearch(test, table)) + await createRows([{ dob: JAN_1ST }, { dob: JAN_10TH }]) }) - } - interface SearchTest> - extends Omit { - expectToFind?: RowType[] - } + describe("equal", () => { + it("successfully finds a row", () => + expectQuery({ equal: { dob: JAN_1ST } }).toFind([{ dob: JAN_1ST }])) - searchTests("strings", { - table: async ds => { - return await config.api.table.save( - tableForDatasource(ds, { - schema: { - name: { - name: "name", - type: FieldType.STRING, - }, - }, - }) - ) - }, - rows: [{ name: "foo" }, { name: "bar" }], - tests: [ - // These test cases are generic and don't really need to be repeated for - // all data types, so we just do them here. + it("fails to find nonexistent row", () => + expectQuery({ equal: { dob: JAN_2ND } }).toFindNothing()) + }) - // @ts-expect-error - intentionally not passing a query to make sure the - // API can handle it. - { expectToFind: [{ name: "foo" }, { name: "bar" }] }, - { query: {}, expectToFind: [{ name: "foo" }, { name: "bar" }] }, - { - query: { onEmptyFilter: EmptyFilterOption.RETURN_ALL }, - expectToFind: [{ name: "foo" }, { name: "bar" }], - }, - { - query: { onEmptyFilter: EmptyFilterOption.RETURN_NONE }, - expectToFind: [], - }, - // The rest of these tests are specific to strings. - { query: { string: { name: "foo" } }, expectToFind: [{ name: "foo" }] }, - { query: { string: { name: "none" } }, expectToFind: [] }, - { query: { fuzzy: { name: "oo" } }, expectToFind: [{ name: "foo" }] }, - { query: { equal: { name: "foo" } }, expectToFind: [{ name: "foo" }] }, - { query: { notEqual: { name: "foo" } }, expectToFind: [{ name: "bar" }] }, - { query: { oneOf: { name: ["foo"] } }, expectToFind: [{ name: "foo" }] }, - ], - }) + describe("notEqual", () => { + it("successfully finds a row", () => + expectQuery({ notEqual: { dob: JAN_1ST } }).toFind([{ dob: JAN_10TH }])) - searchTests("numbers", { - table: async ds => { - return await config.api.table.save( - tableForDatasource(ds, { - schema: { - age: { - name: "age", - type: FieldType.NUMBER, - }, - }, - }) - ) - }, - rows: [{ age: 1 }, { age: 10 }], - tests: [ - { query: { equal: { age: 1 } }, expectToFind: [{ age: 1 }] }, - { query: { equal: { age: 2 } }, expectToFind: [] }, - { query: { notEqual: { age: 1 } }, expectToFind: [{ age: 10 }] }, - { query: { oneOf: { age: [1] } }, expectToFind: [{ age: 1 }] }, - { - query: { range: { age: { low: 1, high: 5 } } }, - expectToFind: [{ age: 1 }], - }, - { - query: { range: { age: { low: 0, high: 1 } } }, - expectToFind: [{ age: 1 }], - }, - { query: { range: { age: { low: 3, high: 4 } } }, expectToFind: [] }, - { - query: { range: { age: { low: 0, high: 11 } } }, - expectToFind: [{ age: 1 }, { age: 10 }], - }, - ], - }) + it("fails to find nonexistent row", () => + expectQuery({ notEqual: { dob: JAN_10TH } }).toFind([{ dob: JAN_1ST }])) + }) - searchTests("dates", { - table: async ds => { - return await config.api.table.save( - tableForDatasource(ds, { - schema: { - dob: { - name: "dob", - type: FieldType.DATETIME, - }, - }, - }) - ) - }, - rows: [ - { dob: "2020-01-01T00:00:00.000Z" }, - { dob: "2020-01-10T00:00:00.000Z" }, - ], - tests: [ - { - query: { equal: { dob: "2020-01-01T00:00:00.000Z" } }, - expectToFind: [{ dob: "2020-01-01T00:00:00.000Z" }], - }, - { - query: { equal: { dob: "2020-01-02T00:00:00.000Z" } }, - expectToFind: [], - }, - { - query: { notEqual: { dob: "2020-01-01T00:00:00.000Z" } }, - expectToFind: [{ dob: "2020-01-10T00:00:00.000Z" }], - }, - { - query: { oneOf: { dob: ["2020-01-01T00:00:00.000Z"] } }, - expectToFind: [{ dob: "2020-01-01T00:00:00.000Z" }], - }, - { - query: { - range: { - dob: { - low: "2020-01-01T00:00:00.000Z", - high: "2020-01-05T00:00:00.000Z", - }, - }, - }, - expectToFind: [{ dob: "2020-01-01T00:00:00.000Z" }], - }, - { - query: { - range: { - dob: { - low: "2020-01-01T00:00:00.000Z", - high: "2020-01-10T00:00:00.000Z", - }, - }, - }, - expectToFind: [ - { dob: "2020-01-01T00:00:00.000Z" }, - { dob: "2020-01-10T00:00:00.000Z" }, - ], - }, - { - query: { - range: { - dob: { - low: "2020-01-05T00:00:00.000Z", - high: "2020-01-10T00:00:00.000Z", - }, - }, - }, - expectToFind: [{ dob: "2020-01-10T00:00:00.000Z" }], - }, - ], + describe("oneOf", () => { + it("successfully finds a row", () => + expectQuery({ oneOf: { dob: [JAN_1ST] } }).toFind([{ dob: JAN_1ST }])) + + it("fails to find nonexistent row", () => + expectQuery({ oneOf: { dob: [JAN_2ND] } }).toFindNothing()) + }) + + describe("range", () => { + it("successfully finds a row", () => + expectQuery({ + range: { dob: { low: JAN_1ST, high: JAN_5TH } }, + }).toFind([{ dob: JAN_1ST }])) + + it("successfully finds multiple rows", () => + expectQuery({ + range: { dob: { low: JAN_1ST, high: JAN_10TH } }, + }).toFind([{ dob: JAN_1ST }, { dob: JAN_10TH }])) + + it("successfully finds a row with a high bound", () => + expectQuery({ + range: { dob: { low: JAN_5TH, high: JAN_10TH } }, + }).toFind([{ dob: JAN_10TH }])) + }) }) }) From a044ba226a76f3a5960f4cae580967b4e01861d8 Mon Sep 17 00:00:00 2001 From: melohagan <101575380+melohagan@users.noreply.github.com> Date: Thu, 11 Apr 2024 15:25:36 +0100 Subject: [PATCH 12/16] ignore key action if posthog survey is focused (#13466) --- .../_components/ComponentList/ComponentKeyHandler.svelte | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/packages/builder/src/pages/builder/app/[application]/design/[screenId]/_components/ComponentList/ComponentKeyHandler.svelte b/packages/builder/src/pages/builder/app/[application]/design/[screenId]/_components/ComponentList/ComponentKeyHandler.svelte index 7e9c113a77..6b27d79c15 100644 --- a/packages/builder/src/pages/builder/app/[application]/design/[screenId]/_components/ComponentList/ComponentKeyHandler.svelte +++ b/packages/builder/src/pages/builder/app/[application]/design/[screenId]/_components/ComponentList/ComponentKeyHandler.svelte @@ -137,8 +137,12 @@ const activeTag = document.activeElement?.tagName.toLowerCase() const inCodeEditor = document.activeElement?.classList?.contains("cm-content") + const inPosthogSurvey = + document.activeElement?.classList?.[0]?.startsWith("PostHogSurvey") if ( - (inCodeEditor || ["input", "textarea"].indexOf(activeTag) !== -1) && + (inCodeEditor || + inPosthogSurvey || + ["input", "textarea"].indexOf(activeTag) !== -1) && e.key !== "Escape" ) { return From 13bb099d40f2506951fdf03163fcfd62680f07c8 Mon Sep 17 00:00:00 2001 From: Budibase Staging Release Bot <> Date: Thu, 11 Apr 2024 14:28:26 +0000 Subject: [PATCH 13/16] Bump version to 2.23.4 --- lerna.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lerna.json b/lerna.json index 385d86209a..78a3aa13e9 100644 --- a/lerna.json +++ b/lerna.json @@ -1,5 +1,5 @@ { - "version": "2.23.3", + "version": "2.23.4", "npmClient": "yarn", "packages": [ "packages/*", From f9e1f4b8c4a5d63d2bbea184b29c69ad5279575c Mon Sep 17 00:00:00 2001 From: mike12345567 Date: Thu, 11 Apr 2024 15:58:22 +0100 Subject: [PATCH 14/16] Fixing issue with OSS build, if the user is OSS don't attempt to account portal build. --- .github/workflows/budibase_ci.yml | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/.github/workflows/budibase_ci.yml b/.github/workflows/budibase_ci.yml index 6120290d0d..536992d655 100644 --- a/.github/workflows/budibase_ci.yml +++ b/.github/workflows/budibase_ci.yml @@ -64,10 +64,11 @@ jobs: - run: yarn --frozen-lockfile # Run build all the projects - - name: Build - run: | - yarn build:oss - yarn build:account-portal + - name: Build OSS + run: yarn build:oss + - name: Build account portal + run: yarn build:account-portal + if: inputs.run_as_oss != true # Check the types of the projects built via esbuild - name: Check types run: | From b8685dc24558deffa253080b4cc9dc32835c86ef Mon Sep 17 00:00:00 2001 From: mike12345567 Date: Thu, 11 Apr 2024 16:24:11 +0100 Subject: [PATCH 15/16] Updating if statement. --- .github/workflows/budibase_ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/budibase_ci.yml b/.github/workflows/budibase_ci.yml index 536992d655..fd4d8cf7c8 100644 --- a/.github/workflows/budibase_ci.yml +++ b/.github/workflows/budibase_ci.yml @@ -68,7 +68,7 @@ jobs: run: yarn build:oss - name: Build account portal run: yarn build:account-portal - if: inputs.run_as_oss != true + if: ${{ env.IS_OSS_CONTRIBUTOR == 'false' }} # Check the types of the projects built via esbuild - name: Check types run: | From bf223f1f09823363c01506451fb94c5cdfed40a5 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Fri, 12 Apr 2024 09:57:34 +0100 Subject: [PATCH 16/16] Increase the base Minio storage to 2Gi in Helm chart. --- charts/budibase/values.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/charts/budibase/values.yaml b/charts/budibase/values.yaml index 19b6c22d6c..48ed1b74dd 100644 --- a/charts/budibase/values.yaml +++ b/charts/budibase/values.yaml @@ -488,7 +488,7 @@ services: # do this. url: "http://minio-service:9000" # -- How much storage to give Minio in its PersistentVolumeClaim. - storage: 100Mi + storage: 2Gi # -- If defined, storageClassName: If set to "-", # storageClassName: "", which disables dynamic provisioning If undefined # (the default) or set to null, no storageClassName spec is set, choosing