CodeMirror/budibase
1
0
Fork 0
mirror of synced 2024-07-03 21:40:55 +12:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into feature/form-screen-template

Browse source
This commit is contained in:
deanhannigan 2024-02-27 12:20:36 +00:00 committed by GitHub
parent ea978923cb 3d48a8f7f3
commit 79ed0e0d89
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
44 changed files with 3969 additions and 339 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.20.10",
"version": "2.20.11",
"npmClient": "yarn",
"packages": [
"packages/*",

2
packages/account-portal

@ -1 +1 @@
Subproject commit ab324e35d855012bd0f49caa53c6dd765223c6fa
Subproject commit de6d44c372a7f48ca0ce8c6c0c19311d4bc21646

2
packages/backend-core/src/objectStore/buckets/plugins.ts
View file

@ -6,7 +6,7 @@ import { Plugin } from "@budibase/types"
// URLS
export function enrichPluginURLs(plugins: Plugin[]) {
export function enrichPluginURLs(plugins?: Plugin[]): Plugin[] {
if (!plugins || !plugins.length) {
return []
}

1
packages/backend-core/src/redis/utils.ts
View file

@ -29,6 +29,7 @@ export enum Databases {
WRITE_THROUGH = "writeThrough",
LOCKS = "locks",
SOCKET_IO = "socket_io",
BPM_EVENTS = "bpmEvents",
}
/**

17
packages/builder/src/components/common/HelpMenu.svelte
View file

@ -1,11 +1,11 @@
<script>
import FontAwesomeIcon from "./FontAwesomeIcon.svelte"
import { Popover, Heading, Body } from "@budibase/bbui"
import { licensing } from "stores/portal"
import { isEnabled, TENANT_FEATURE_FLAGS } from "helpers/featureFlags"
import { licensing } from "stores/portal"
import { isPremiumOrAbove } from "helpers/planTitle"
$: isBusinessAndAbove =
$licensing.isBusinessPlan || $licensing.isEnterprisePlan
$: premiumOrAboveLicense = isPremiumOrAbove($licensing?.license.plan.type)
let show
let hide
@ -56,22 +56,25 @@
<div class="divider" />
{#if isEnabled(TENANT_FEATURE_FLAGS.LICENSING)}
<a
href={isBusinessAndAbove
href={premiumOrAboveLicense
? "mailto:support@budibase.com"
: "/builder/portal/account/usage"}
>
<div class="premiumLinkContent" class:disabled={!isBusinessAndAbove}>
<div
class="premiumLinkContent"
class:disabled={!premiumOrAboveLicense}
>
<div class="icon">
<FontAwesomeIcon name="fa-solid fa-envelope" />
</div>
<Body size="S">Email support</Body>
</div>
{#if !isBusinessAndAbove}
{#if !premiumOrAboveLicense}
<div class="premiumBadge">
<div class="icon">
<FontAwesomeIcon name="fa-solid fa-lock" />
</div>
<Body size="XS">Business</Body>
<Body size="XS">Premium</Body>
</div>
{/if}
</a>

102
packages/builder/src/components/design/settings/controls/ButtonActionEditor/actions/ExportData.svelte
View file

@ -1,9 +1,9 @@
<script>
import { Label, Select, Body, Multiselect } from "@budibase/bbui"
import { findAllMatchingComponents, findComponent } from "helpers/components"
import { selectedScreen } from "stores/builder"
import { Label, Select, Body } from "@budibase/bbui"
import { onMount } from "svelte"
import { getDatasourceForProvider, getSchemaForDatasource } from "dataBinding"
import ColumnEditor from "../../ColumnEditor/ColumnEditor.svelte"
import { findAllMatchingComponents } from "helpers/components"
import { selectedScreen } from "stores/builder"
export let parameters
@ -18,37 +18,65 @@
},
]
const DELIMITERS = [
{
label: ",",
value: ",",
},
{
label: ";",
value: ";",
},
{
label: ":",
value: ":",
},
{
label: "|",
value: "|",
},
{
label: "~",
value: "~",
},
{
label: "[tab]",
value: "\t",
},
{
label: "[space]",
value: " ",
},
]
$: tables = findAllMatchingComponents($selectedScreen?.props, component =>
component._component.endsWith("table")
).map(table => ({
label: table._instanceName,
value: table._id,
}))
)
$: tableBlocks = findAllMatchingComponents(
$selectedScreen?.props,
component => component._component.endsWith("tableblock")
).map(block => ({
label: block._instanceName,
value: `${block._id}-table`,
)
$: components = tables.concat(tableBlocks)
$: componentOptions = components.map(table => ({
label: table._instanceName,
value: table._component.includes("tableblock")
? `${table._id}-table`
: table._id,
}))
$: componentOptions = tables.concat(tableBlocks)
$: columnOptions = getColumnOptions(parameters.tableComponentId)
const getColumnOptions = tableId => {
// Strip block suffix if block component
if (tableId?.includes("-")) {
tableId = tableId.split("-")[0]
}
const selectedTable = findComponent($selectedScreen?.props, tableId)
const datasource = getDatasourceForProvider($selectedScreen, selectedTable)
const { schema } = getSchemaForDatasource($selectedScreen, datasource)
return Object.keys(schema || {})
}
$: selectedTableId = parameters.tableComponentId?.includes("-")
? parameters.tableComponentId.split("-")[0]
: parameters.tableComponentId
$: selectedTable = components.find(
component => component._id === selectedTableId
)
onMount(() => {
if (!parameters.type) {
parameters.type = "csv"
}
if (!parameters.delimiter) {
parameters.delimiter = ","
}
})
</script>
@ -67,13 +95,29 @@
options={componentOptions}
on:change={() => (parameters.columns = [])}
/>
<span />
<Label small>Export as</Label>
<Select bind:value={parameters.type} options={FORMATS} />
<Select
bind:value={parameters.delimiter}
placeholder={null}
options={DELIMITERS}
disabled={parameters.type !== "csv"}
/>
<Label small>Export columns</Label>
<Multiselect
placeholder="All columns"
<ColumnEditor
bind:value={parameters.columns}
options={columnOptions}
allowCellEditing={false}
componentInstance={selectedTable}
on:change={e => {
const columns = e.detail
parameters.customHeaders = columns.reduce((headerMap, column) => {
return {
[column.name]: column.displayName,
...headerMap,
}
}, {})
}}
/>
</div>
</div>
@ -97,8 +141,8 @@
.params {
display: grid;
column-gap: var(--spacing-xs);
row-gap: var(--spacing-s);
grid-template-columns: 90px 1fr;
row-gap: var(--spacing-m);
grid-template-columns: 90px 1fr 90px;
align-items: center;
}
</style>

6
packages/builder/src/components/design/settings/controls/ColumnEditor/ColumnEditor.svelte
View file

@ -29,6 +29,12 @@
allowLinks: true,
})
$: {
value = (value || []).filter(
column => (schema || {})[column.name || column] !== undefined
)
}
const getText = value => {
if (!value?.length) {
return "All columns"

6
packages/builder/src/helpers/data/utils.js
View file

@ -17,6 +17,10 @@ export function breakQueryString(qs) {
return paramObj
}
function isEncoded(str) {
return typeof str == "string" && decodeURIComponent(str) !== str
}
export function buildQueryString(obj) {
let str = ""
if (obj) {
@ -35,7 +39,7 @@ export function buildQueryString(obj) {
value = value.replace(binding, marker)
bindingMarkers[marker] = binding
})
let encoded = encodeURIComponent(value || "")
let encoded = isEncoded(value) ? value : encodeURIComponent(value || "")
Object.entries(bindingMarkers).forEach(([marker, binding]) => {
encoded = encoded.replace(marker, binding)
})

4
packages/builder/src/helpers/planTitle.js
View file

@ -25,3 +25,7 @@ export function getFormattedPlanName(userPlanType) {
}
return `${planName} Plan`
}
export function isPremiumOrAbove(userPlanType) {
return ![PlanType.PRO, PlanType.TEAM, PlanType.FREE].includes(userPlanType)
}

7
packages/builder/src/helpers/tests/dataUtils.test.js
View file

@ -39,4 +39,11 @@ describe("check query string utils", () => {
expect(broken.key1).toBe(obj2.key1)
expect(broken.key2).toBe(obj2.key2)
})
it("should not encode a URL more than once when building the query string", () => {
const queryString = buildQueryString({
values: "a%2Cb%2Cc",
})
expect(queryString).toBe("values=a%2Cb%2Cc")
})
})

6
packages/client/src/utils/buttonActions.js
View file

@ -341,7 +341,11 @@ const exportDataHandler = async action => {
tableId: selection.tableId,
rows: selection.selectedRows,
format: action.parameters.type,
columns: action.parameters.columns,
columns: action.parameters.columns?.map(
column => column.name || column
),
delimiter: action.parameters.delimiter,
customHeaders: action.parameters.customHeaders,
})
download(
new Blob([data], { type: "text/plain" }),

13
packages/frontend-core/src/api/rows.js
View file

@ -89,13 +89,24 @@ export const buildRowEndpoints = API => ({
* @param rows the array of rows to export
* @param format the format to export (csv or json)
* @param columns which columns to export (all if undefined)
* @param delimiter how values should be separated in a CSV (default is comma)
*/
exportRows: async ({ tableId, rows, format, columns, search }) => {
exportRows: async ({
tableId,
rows,
format,
columns,
search,
delimiter,
customHeaders,
}) => {
return await API.post({
url: `/api/${tableId}/rows/exportRows?format=${format}`,
body: {
rows,
columns,
delimiter,
customHeaders,
...search,
},
parseResponse: async response => {

9
packages/sdk/package.json
View file

@ -11,9 +11,10 @@
"build:sdk": "yarn run generate && rollup -c"
},
"devDependencies": {
"@rollup/plugin-commonjs": "^18.0.0",
"@rollup/plugin-node-resolve": "^11.2.1",
"rollup": "^2.44.0",
"rollup-plugin-terser": "^7.0.2"
"@rollup/plugin-commonjs": "^25.0.7",
"@rollup/plugin-node-resolve": "^15.2.3",
"rollup": "^4.9.6",
"rollup-plugin-terser": "^7.0.2",
"rollup-plugin-polyfill-node": "^0.13.0"
}
}

4
packages/server/scripts/test.sh
View file

@ -3,12 +3,12 @@ set -e
if [[ -n $CI ]]
then
export NODE_OPTIONS="--max-old-space-size=4096 --no-node-snapshot"
export NODE_OPTIONS="--max-old-space-size=4096 --no-node-snapshot $NODE_OPTIONS"
echo "jest --coverage --maxWorkers=2 --forceExit --workerIdleMemoryLimit=2000MB --bail $@"
jest --coverage --maxWorkers=2 --forceExit --workerIdleMemoryLimit=2000MB --bail $@
else
# --maxWorkers performs better in development
export NODE_OPTIONS="--no-node-snapshot"
export NODE_OPTIONS="--no-node-snapshot $NODE_OPTIONS"
echo "jest --coverage --maxWorkers=2 --forceExit $@"
jest --coverage --maxWorkers=2 --forceExit $@
fi

60
packages/server/src/api/controllers/application.ts
View file

@ -47,6 +47,9 @@ import {
PlanType,
Screen,
UserCtx,
CreateAppRequest,
FetchAppDefinitionResponse,
FetchAppPackageResponse,
} from "@budibase/types"
import { BASE_LAYOUT_PROP_IDS } from "../../constants/layouts"
import sdk from "../../sdk"
@ -58,23 +61,23 @@ import * as appMigrations from "../../appMigrations"
async function getLayouts() {
const db = context.getAppDB()
return (
await db.allDocs(
await db.allDocs<Layout>(
getLayoutParams(null, {
include_docs: true,
})
)
).rows.map((row: any) => row.doc)
).rows.map(row => row.doc!)
}
async function getScreens() {
const db = context.getAppDB()
return (
await db.allDocs(
await db.allDocs<Screen>(
getScreenParams(null, {
include_docs: true,
})
)
).rows.map((row: any) => row.doc)
).rows.map(row => row.doc!)
}
function getUserRoleId(ctx: UserCtx) {
@ -116,8 +119,8 @@ function checkAppName(
}
interface AppTemplate {
templateString: string
useTemplate: string
templateString?: string
useTemplate?: string
file?: {
type: string
path: string
@ -174,14 +177,16 @@ export const addSampleData = async (ctx: UserCtx) => {
ctx.status = 200
}
export async function fetch(ctx: UserCtx) {
export async function fetch(ctx: UserCtx<void, App[]>) {
ctx.body = await sdk.applications.fetch(
ctx.query.status as AppStatus,
ctx.user
)
}
export async function fetchAppDefinition(ctx: UserCtx) {
export async function fetchAppDefinition(
ctx: UserCtx<void, FetchAppDefinitionResponse>
) {
const layouts = await getLayouts()
const userRoleId = getUserRoleId(ctx)
const accessController = new roles.AccessController()
@ -196,10 +201,12 @@ export async function fetchAppDefinition(ctx: UserCtx) {
}
}
export async function fetchAppPackage(ctx: UserCtx) {
export async function fetchAppPackage(
ctx: UserCtx<void, FetchAppPackageResponse>
) {
const db = context.getAppDB()
const appId = context.getAppId()
let application = await db.get<any>(DocumentType.APP_METADATA)
let application = await db.get<App>(DocumentType.APP_METADATA)
const layouts = await getLayouts()
let screens = await getScreens()
const license = await licensing.cache.getCachedLicense()
@ -231,17 +238,21 @@ export async function fetchAppPackage(ctx: UserCtx) {
}
}
async function performAppCreate(ctx: UserCtx) {
async function performAppCreate(ctx: UserCtx<CreateAppRequest, App>) {
const apps = (await dbCore.getAllApps({ dev: true })) as App[]
const name = ctx.request.body.name,
possibleUrl = ctx.request.body.url,
encryptionPassword = ctx.request.body.encryptionPassword
const {
name,
url,
encryptionPassword,
useTemplate,
templateKey,
templateString,
} = ctx.request.body
checkAppName(ctx, apps, name)
const url = sdk.applications.getAppUrl({ name, url: possibleUrl })
checkAppUrl(ctx, apps, url)
const appUrl = sdk.applications.getAppUrl({ name, url })
checkAppUrl(ctx, apps, appUrl)
const { useTemplate, templateKey, templateString } = ctx.request.body
const instanceConfig: AppTemplate = {
useTemplate,
key: templateKey,
@ -268,7 +279,7 @@ async function performAppCreate(ctx: UserCtx) {
version: envCore.VERSION,
componentLibraries: ["@budibase/standard-components"],
name: name,
url: url,
url: appUrl,
template: templateKey,
instance,
tenantId: tenancy.getTenantId(),
@ -420,7 +431,9 @@ export async function create(ctx: UserCtx) {
// This endpoint currently operates as a PATCH rather than a PUT
// Thus name and url fields are handled only if present
export async function update(ctx: UserCtx) {
export async function update(
ctx: UserCtx<{ name?: string; url?: string }, App>
) {
const apps = (await dbCore.getAllApps({ dev: true })) as App[]
// validation
const name = ctx.request.body.name,
@ -493,7 +506,7 @@ export async function revertClient(ctx: UserCtx) {
const revertedToVersion = application.revertableVersion
const appPackageUpdates = {
version: revertedToVersion,
revertableVersion: null,
revertableVersion: undefined,
}
const app = await updateAppPackage(appPackageUpdates, ctx.params.appId)
await events.app.versionReverted(app, currentVersion, revertedToVersion)
@ -613,12 +626,15 @@ export async function importToApp(ctx: UserCtx) {
ctx.body = { message: "app updated" }
}
export async function updateAppPackage(appPackage: any, appId: any) {
export async function updateAppPackage(
appPackage: Partial<App>,
appId: string
) {
return context.doInAppContext(appId, async () => {
const db = context.getAppDB()
const application = await db.get<App>(DocumentType.APP_METADATA)
const newAppPackage = { ...application, ...appPackage }
const newAppPackage: App = { ...application, ...appPackage }
if (appPackage._rev !== application._rev) {
newAppPackage._rev = application._rev
}

5
packages/server/src/api/controllers/row/index.ts
View file

@ -223,7 +223,8 @@ export const exportRows = async (
const format = ctx.query.format
const { rows, columns, query, sort, sortOrder } = ctx.request.body
const { rows, columns, query, sort, sortOrder, delimiter, customHeaders } =
ctx.request.body
if (typeof format !== "string" || !exporters.isFormat(format)) {
ctx.throw(
400,
@ -241,6 +242,8 @@ export const exportRows = async (
query,
sort,
sortOrder,
delimiter,
customHeaders,
})
ctx.attachment(fileName)
ctx.body = apiFileReturn(content)

6
packages/server/src/api/controllers/script.ts
View file

@ -1,13 +1,11 @@
import { Ctx } from "@budibase/types"
import { IsolatedVM } from "../../jsRunner/vm"
import { iifeWrapper } from "../../jsRunner/utilities"
export async function execute(ctx: Ctx) {
const { script, context } = ctx.request.body
const vm = new IsolatedVM()
const result = vm.withContext(context, () =>
vm.execute(`(function(){\n${script}\n})();`)
)
ctx.body = result
ctx.body = vm.withContext(context, () => vm.execute(iifeWrapper(script)))
}
export async function save(ctx: Ctx) {

18
packages/server/src/api/controllers/view/exporters.ts
View file

@ -1,7 +1,19 @@
import { Row, TableSchema } from "@budibase/types"
export function csv(headers: string[], rows: Row[]) {
let csv = headers.map(key => `"${key}"`).join(",")
function getHeaders(
headers: string[],
customHeaders: { [key: string]: string }
) {
return headers.map(header => `"${customHeaders[header] || header}"`)
}
export function csv(
headers: string[],
rows: Row[],
delimiter: string = ",",
customHeaders: { [key: string]: string } = {}
) {
let csv = getHeaders(headers, customHeaders).join(delimiter)
for (let row of rows) {
csv = `${csv}\n${headers
@ -15,7 +27,7 @@ export function csv(headers: string[], rows: Row[]) {
: ""
return val.trim()
})
.join(",")}`
.join(delimiter)}`
}
return csv
}

1
packages/server/src/api/routes/application.ts
View file

@ -4,7 +4,6 @@ import * as deploymentController from "../controllers/deploy"
import authorized from "../../middleware/authorized"
import { permissions } from "@budibase/backend-core"
import { applicationValidator } from "./utils/validators"
import { importToApp } from "../controllers/application"
const router: Router = new Router()

287
packages/server/src/api/routes/tests/application.spec.ts
View file

@ -11,65 +11,54 @@ jest.mock("../../../utilities/redis", () => ({
checkDebounce: jest.fn(),
shutdown: jest.fn(),
}))
import { clearAllApps, checkBuilderEndpoint } from "./utilities/TestFunctions"
import { checkBuilderEndpoint } from "./utilities/TestFunctions"
import * as setup from "./utilities"
import { AppStatus } from "../../../db/utils"
import { events, utils, context } from "@budibase/backend-core"
import env from "../../../environment"
jest.setTimeout(15000)
import type { App } from "@budibase/types"
import tk from "timekeeper"
describe("/applications", () => {
let request = setup.getRequest()
let config = setup.getConfig()
let app: App
afterAll(setup.afterAll)
beforeAll(async () => {
await config.init()
})
beforeAll(async () => await config.init())
beforeEach(async () => {
app = await config.api.application.create({ name: utils.newid() })
const deployment = await config.api.application.publish(app.appId)
expect(deployment.status).toBe("SUCCESS")
jest.clearAllMocks()
})
describe("create", () => {
it("creates empty app", async () => {
const res = await request
.post("/api/applications")
.field("name", utils.newid())
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body._id).toBeDefined()
const app = await config.api.application.create({ name: utils.newid() })
expect(app._id).toBeDefined()
expect(events.app.created).toBeCalledTimes(1)
})
it("creates app from template", async () => {
const res = await request
.post("/api/applications")
.field("name", utils.newid())
.field("useTemplate", "true")
.field("templateKey", "test")
.field("templateString", "{}") // override the file download
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body._id).toBeDefined()
const app = await config.api.application.create({
name: utils.newid(),
useTemplate: "true",
templateKey: "test",
templateString: "{}",
})
expect(app._id).toBeDefined()
expect(events.app.created).toBeCalledTimes(1)
expect(events.app.templateImported).toBeCalledTimes(1)
})
it("creates app from file", async () => {
const res = await request
.post("/api/applications")
.field("name", utils.newid())
.field("useTemplate", "true")
.set(config.defaultHeaders())
.attach("templateFile", "src/api/routes/tests/data/export.txt")
.expect("Content-Type", /json/)
.expect(200)
expect(res.body._id).toBeDefined()
const app = await config.api.application.create({
name: utils.newid(),
useTemplate: "true",
templateFile: "src/api/routes/tests/data/export.txt",
})
expect(app._id).toBeDefined()
expect(events.app.created).toBeCalledTimes(1)
expect(events.app.fileImported).toBeCalledTimes(1)
})
@ -84,24 +73,21 @@ describe("/applications", () => {
})
it("migrates navigation settings from old apps", async () => {
const res = await request
.post("/api/applications")
.field("name", "Old App")
.field("useTemplate", "true")
.set(config.defaultHeaders())
.attach("templateFile", "src/api/routes/tests/data/old-app.txt")
.expect("Content-Type", /json/)
.expect(200)
expect(res.body._id).toBeDefined()
expect(res.body.navigation).toBeDefined()
expect(res.body.navigation.hideLogo).toBe(true)
expect(res.body.navigation.title).toBe("Custom Title")
expect(res.body.navigation.hideLogo).toBe(true)
expect(res.body.navigation.navigation).toBe("Left")
expect(res.body.navigation.navBackground).toBe(
const app = await config.api.application.create({
name: utils.newid(),
useTemplate: "true",
templateFile: "src/api/routes/tests/data/old-app.txt",
})
expect(app._id).toBeDefined()
expect(app.navigation).toBeDefined()
expect(app.navigation!.hideLogo).toBe(true)
expect(app.navigation!.title).toBe("Custom Title")
expect(app.navigation!.hideLogo).toBe(true)
expect(app.navigation!.navigation).toBe("Left")
expect(app.navigation!.navBackground).toBe(
"var(--spectrum-global-color-blue-600)"
)
expect(res.body.navigation.navTextColor).toBe(
expect(app.navigation!.navTextColor).toBe(
"var(--spectrum-global-color-gray-50)"
)
expect(events.app.created).toBeCalledTimes(1)
@ -110,164 +96,106 @@ describe("/applications", () => {
})
describe("fetch", () => {
beforeEach(async () => {
// Clean all apps but the onde from config
await clearAllApps(config.getTenantId(), [config.getAppId()!])
})
it("lists all applications", async () => {
await config.createApp("app1")
await config.createApp("app2")
const res = await request
.get(`/api/applications?status=${AppStatus.DEV}`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
// two created apps + the inited app
expect(res.body.length).toBe(3)
const apps = await config.api.application.fetch({ status: AppStatus.DEV })
expect(apps.length).toBeGreaterThan(0)
})
})
describe("fetchAppDefinition", () => {
it("should be able to get an apps definition", async () => {
const res = await request
.get(`/api/applications/${config.getAppId()}/definition`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body.libraries.length).toEqual(1)
const res = await config.api.application.getDefinition(app.appId)
expect(res.libraries.length).toEqual(1)
})
})
describe("fetchAppPackage", () => {
it("should be able to fetch the app package", async () => {
const res = await request
.get(`/api/applications/${config.getAppId()}/appPackage`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body.application).toBeDefined()
expect(res.body.application.appId).toEqual(config.getAppId())
const res = await config.api.application.getAppPackage(app.appId)
expect(res.application).toBeDefined()
expect(res.application.appId).toEqual(config.getAppId())
})
})
describe("update", () => {
it("should be able to update the app package", async () => {
const res = await request
.put(`/api/applications/${config.getAppId()}`)
.send({
name: "TEST_APP",
})
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body._rev).toBeDefined()
const updatedApp = await config.api.application.update(app.appId, {
name: "TEST_APP",
})
expect(updatedApp._rev).toBeDefined()
expect(events.app.updated).toBeCalledTimes(1)
})
})
describe("publish", () => {
it("should publish app with dev app ID", async () => {
const appId = config.getAppId()
await request
.post(`/api/applications/${appId}/publish`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.publish(app.appId)
expect(events.app.published).toBeCalledTimes(1)
})
it("should publish app with prod app ID", async () => {
const appId = config.getProdAppId()
await request
.post(`/api/applications/${appId}/publish`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.publish(app.appId.replace("_dev", ""))
expect(events.app.published).toBeCalledTimes(1)
})
})
describe("manage client library version", () => {
it("should be able to update the app client library version", async () => {
await request
.post(`/api/applications/${config.getAppId()}/client/update`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.updateClient(app.appId)
expect(events.app.versionUpdated).toBeCalledTimes(1)
})
it("should be able to revert the app client library version", async () => {
// We need to first update the version so that we can then revert
await request
.post(`/api/applications/${config.getAppId()}/client/update`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await request
.post(`/api/applications/${config.getAppId()}/client/revert`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.updateClient(app.appId)
await config.api.application.revertClient(app.appId)
expect(events.app.versionReverted).toBeCalledTimes(1)
})
})
describe("edited at", () => {
it("middleware should set edited at", async () => {
const headers = config.defaultHeaders()
headers["referer"] = `/${config.getAppId()}/test`
const res = await request
.put(`/api/applications/${config.getAppId()}`)
.send({
name: "UPDATED_NAME",
})
.set(headers)
.expect("Content-Type", /json/)
.expect(200)
expect(res.body._rev).toBeDefined()
// retrieve the app to check it
const getRes = await request
.get(`/api/applications/${config.getAppId()}/appPackage`)
.set(headers)
.expect("Content-Type", /json/)
.expect(200)
expect(getRes.body.application.updatedAt).toBeDefined()
it("middleware should set updatedAt", async () => {
const app = await tk.withFreeze(
"2021-01-01",
async () => await config.api.application.create({ name: utils.newid() })
)
expect(app.updatedAt).toEqual("2021-01-01T00:00:00.000Z")
const updatedApp = await tk.withFreeze(
"2021-02-01",
async () =>
await config.api.application.update(app.appId, {
name: "UPDATED_NAME",
})
)
expect(updatedApp._rev).toBeDefined()
expect(updatedApp.updatedAt).toEqual("2021-02-01T00:00:00.000Z")
const fetchedApp = await config.api.application.get(app.appId)
expect(fetchedApp.updatedAt).toEqual("2021-02-01T00:00:00.000Z")
})
})
describe("sync", () => {
it("app should sync correctly", async () => {
const res = await request
.post(`/api/applications/${config.getAppId()}/sync`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body.message).toEqual("App sync completed successfully.")
const { message } = await config.api.application.sync(app.appId)
expect(message).toEqual("App sync completed successfully.")
})
it("app should not sync if production", async () => {
const res = await request
.post(`/api/applications/app_123456/sync`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(400)
expect(res.body.message).toEqual(
const { message } = await config.api.application.sync(
app.appId.replace("_dev", ""),
{ statusCode: 400 }
)
expect(message).toEqual(
"This action cannot be performed for production apps"
)
})
it("app should not sync if sync is disabled", async () => {
env._set("DISABLE_AUTO_PROD_APP_SYNC", true)
const res = await request
.post(`/api/applications/${config.getAppId()}/sync`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
expect(res.body.message).toEqual(
const { message } = await config.api.application.sync(app.appId)
expect(message).toEqual(
"App sync disabled. You can reenable with the DISABLE_AUTO_PROD_APP_SYNC environment variable."
)
env._set("DISABLE_AUTO_PROD_APP_SYNC", false)
@ -275,51 +203,26 @@ describe("/applications", () => {
})
describe("unpublish", () => {
beforeEach(async () => {
// We want to republish as the unpublish will delete the prod app
await config.publish()
})
it("should unpublish app with dev app ID", async () => {
const appId = config.getAppId()
await request
.post(`/api/applications/${appId}/unpublish`)
.set(config.defaultHeaders())
.expect(204)
await config.api.application.unpublish(app.appId)
expect(events.app.unpublished).toBeCalledTimes(1)
})
it("should unpublish app with prod app ID", async () => {
const appId = config.getProdAppId()
await request
.post(`/api/applications/${appId}/unpublish`)
.set(config.defaultHeaders())
.expect(204)
await config.api.application.unpublish(app.appId.replace("_dev", ""))
expect(events.app.unpublished).toBeCalledTimes(1)
})
})
describe("delete", () => {
it("should delete published app and dev apps with dev app ID", async () => {
await config.createApp("to-delete")
const appId = config.getAppId()
await request
.delete(`/api/applications/${appId}`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.delete(app.appId)
expect(events.app.deleted).toBeCalledTimes(1)
expect(events.app.unpublished).toBeCalledTimes(1)
})
it("should delete published app and dev app with prod app ID", async () => {
await config.createApp("to-delete")
const appId = config.getProdAppId()
await request
.delete(`/api/applications/${appId}`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.delete(app.appId.replace("_dev", ""))
expect(events.app.deleted).toBeCalledTimes(1)
expect(events.app.unpublished).toBeCalledTimes(1)
})
@ -327,28 +230,18 @@ describe("/applications", () => {
describe("POST /api/applications/:appId/sync", () => {
it("should not sync automation logs", async () => {
// setup the apps
await config.createApp("testing-auto-logs")
const automation = await config.createAutomation()
await config.publish()
await context.doInAppContext(config.getProdAppId(), () => {
return config.createAutomationLog(automation)
})
await context.doInAppContext(app.appId, () =>
config.createAutomationLog(automation)
)
// do the sync
const appId = config.getAppId()
await request
.post(`/api/applications/${appId}/sync`)
.set(config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
await config.api.application.sync(app.appId)
// does exist in prod
const prodLogs = await config.getAutomationLogs()
expect(prodLogs.data.length).toBe(1)
// delete prod app so we revert to dev log search
await config.unpublish()
await config.api.application.unpublish(app.appId)
// doesn't exist in dev
const devLogs = await config.getAutomationLogs()

1
packages/server/src/jsRunner/index.ts
View file

@ -7,7 +7,6 @@ import {
} from "@budibase/string-templates"
import { context, logging } from "@budibase/backend-core"
import tracer from "dd-trace"
import { IsolatedVM } from "./vm"
export function init() {

110
packages/server/src/jsRunner/tests/isolatedVM.spec.ts Normal file
View file

@ -0,0 +1,110 @@
import fs from "fs"
import path from "path"
import { IsolatedVM } from "../vm"
import { iifeWrapper } from "../utilities"
function runJSWithIsolatedVM(script: string, context: Record<string, any>) {
const runner = new IsolatedVM()
return runner.withContext(context, () => {
return runner.execute(iifeWrapper(script))
})
}
describe("Test isolated vm directly", () => {
it("should handle a very large file", () => {
const marked = fs.readFileSync(
path.join(__dirname, "largeJSExample.txt"),
"utf-8"
)
const result = runJSWithIsolatedVM(marked, {
trigger: { row: { Message: "dddd" } },
})
expect(result).toBe("<p>dddd</p>\n")
})
it("handle a mapping case", async () => {
const context = {
data: {
data: {
searchProducts: {
results: [{ imageLinks: ["_S/"] }],
},
},
},
}
const result = await runJSWithIsolatedVM(
`
const dataUnnested = data.data.searchProducts.results
const emptyLink = "https://budibase.com"
let pImage = emptyLink
let sImage = emptyLink
let uImage = emptyLink
let lImage = emptyLink
let b1Image = emptyLink
let b2Image = emptyLink
const dataTransformed = dataUnnested.map(x=> {
let imageLinks = x.imageLinks
for (let i = 0; i < imageLinks.length; i++){
if(imageLinks[i].includes("_P/") || imageLinks[i].includes("_p/")){
pImage = imageLinks[i]
} else if (imageLinks[i].includes("_S/") || imageLinks[i].includes("_s/")){
sImage = imageLinks[i]
} else if (imageLinks[i].includes("_U/") || imageLinks[i].includes("_u/")){
uImage = imageLinks[i]
} else if (imageLinks[i].includes("_L/") || imageLinks[i].includes("_l/")){
lImage = imageLinks[i]
} else if (imageLinks[i].includes("_B/") || imageLinks[i].includes("_b/")){
b1Image = imageLinks[i]
} else if (imageLinks[i].includes("_B2/") || imageLinks[i].includes("_b2/")){
b2Image = imageLinks[i]
}
}
const arrangedLinks = [pImage, sImage, uImage, lImage, b1Image, b2Image]
x.imageLinks = arrangedLinks
return x
})
return dataTransformed
`,
context
)
expect(result).toBeDefined()
expect(result.length).toBe(1)
expect(result[0].imageLinks).toEqual([
"https://budibase.com",
"_S/",
"https://budibase.com",
"https://budibase.com",
"https://budibase.com",
"https://budibase.com",
])
})
it("should handle automation script example", () => {
const context = {
steps: [{}, { response: "hello" }, { items: [{ rows: [{ a: 1 }] }] }],
}
const result = runJSWithIsolatedVM(
`const queryResults = steps[2].items;
const intervals = steps[1].response;
const whereNoItemsReturned = [];
let index = 0;
for (let queryResult of queryResults) {
if (queryResult.rows.length === 0) {
whereNoItemsReturned.push(intervals[index]);
}
index++;
}
return whereNoItemsReturned;
`,
context
)
expect(result).toEqual([])
})
})

278
packages/server/src/jsRunner/tests/jsRunner.spec.ts
View file

@ -7,7 +7,9 @@ import tk from "timekeeper"
import { init } from ".."
import TestConfiguration from "../../tests/utilities/TestConfiguration"
tk.freeze("2021-01-21T12:00:00")
const DATE = "2021-01-21T12:00:00"
tk.freeze(DATE)
describe("jsRunner (using isolated-vm)", () => {
const config = new TestConfiguration()
@ -70,4 +72,278 @@ describe("jsRunner (using isolated-vm)", () => {
})
})
})
// the test cases here were extracted from templates/real world examples of JS in Budibase
describe("real test cases from Budicloud", () => {
const context = {
"Unit Value": 2,
Quantity: 1,
}
it("handle test case 1", async () => {
const result = await processJS(
`
var Gross = $("[Unit Value]") * $("[Quantity]")
return Gross.toFixed(2)`,
context
)
expect(result).toBeDefined()
expect(result).toBe("2.00")
})
it("handle test case 2", async () => {
const context = {
"Purchase Date": DATE,
}
const result = await processJS(
`
var purchase = new Date($("[Purchase Date]"));
let purchaseyear = purchase.getFullYear();
let purchasemonth = purchase.getMonth();
var today = new Date ();
let todayyear = today.getFullYear();
let todaymonth = today.getMonth();
var age = todayyear - purchaseyear
if (((todaymonth - purchasemonth) < 6) == true){
return age
}
`,
context
)
expect(result).toBeDefined()
expect(result).toBe(3)
})
it("should handle test case 3", async () => {
const context = {
Escalate: true,
"Budget ($)": 1100,
}
const result = await processJS(
`
if ($("[Escalate]") == true) {
if ($("Budget ($)") <= 1000)
{return 2;}
if ($("Budget ($)") > 1000)
{return 3;}
}
else {
if ($("Budget ($)") <= 1000)
{return 1;}
if ($("Budget ($)") > 1000)
if ($("Budget ($)") < 10000)
{return 2;}
else
{return 3}
}
`,
context
)
expect(result).toBeDefined()
expect(result).toBe(3)
})
it("should handle test case 4", async () => {
const context = {
"Time Sheets": ["a", "b"],
}
const result = await processJS(
`
let hours = 0
if (($("[Time Sheets]") != null) == true){
for (i = 0; i < $("[Time Sheets]").length; i++){
let hoursLogged = "Time Sheets." + i + ".Hours"
hours += $(hoursLogged)
}
return hours
}
if (($("[Time Sheets]") != null) == false){
return hours
}
`,
context
)
expect(result).toBeDefined()
expect(result).toBe("0ab")
})
it("should handle test case 5", async () => {
const context = {
change: JSON.stringify({ a: 1, primaryDisplay: "a" }),
previous: JSON.stringify({ a: 2, primaryDisplay: "b" }),
}
const result = await processJS(
`
let change = $("[change]") ? JSON.parse($("[change]")) : {}
let previous = $("[previous]") ? JSON.parse($("[previous]")) : {}
function simplifyLink(originalKey, value, parent) {
if (Array.isArray(value)) {
if (value.filter(item => Object.keys(item || {}).includes("primaryDisplay")).length > 0) {
parent[originalKey] = value.map(link => link.primaryDisplay)
}
}
}
for (let entry of Object.entries(change)) {
simplifyLink(entry[0], entry[1], change)
}
for (let entry of Object.entries(previous)) {
simplifyLink(entry[0], entry[1], previous)
}
let diff = Object.fromEntries(Object.entries(change).filter(([k, v]) => previous[k]?.toString() !== v?.toString()))
delete diff.audit_change
delete diff.audit_previous
delete diff._id
delete diff._rev
delete diff.tableId
delete diff.audit
for (let entry of Object.entries(diff)) {
simplifyLink(entry[0], entry[1], diff)
}
return JSON.stringify(change)?.replaceAll(",\\"", ",\\n\\t\\"").replaceAll("{\\"", "{\\n\\t\\"").replaceAll("}", "\\n}")
`,
context
)
expect(result).toBe(`{\n\t"a":1,\n\t"primaryDisplay":"a"\n}`)
})
it("should handle test case 6", async () => {
const context = {
"Join Date": DATE,
}
const result = await processJS(
`
var rate = 5;
var today = new Date();
// comment
function monthDiff(dateFrom, dateTo) {
return dateTo.getMonth() - dateFrom.getMonth() +
(12 * (dateTo.getFullYear() - dateFrom.getFullYear()))
}
var serviceMonths = monthDiff( new Date($("[Join Date]")), today);
var serviceYears = serviceMonths / 12;
if (serviceYears >= 1 && serviceYears < 5){
rate = 10;
}
if (serviceYears >= 5 && serviceYears < 10){
rate = 15;
}
if (serviceYears >= 10){
rate = 15;
rate += 0.5 * (Number(serviceYears.toFixed(0)) - 10);
}
return rate;
`,
context
)
expect(result).toBe(10)
})
it("should handle test case 7", async () => {
const context = {
"P I": "Pass",
"PA I": "Pass",
"F I": "Fail",
"V I": "Pass",
}
const result = await processJS(
`if (($("[P I]") == "Pass") == true)
if (($("[ P I]") == "Pass") == true)
if (($("[F I]") == "Pass") == true)
if (($("[V I]") == "Pass") == true)
{return "Pass"}
if (($("[PA I]") == "Fail") == true)
{return "Fail"}
if (($("[ P I]") == "Fail") == true)
{return "Fail"}
if (($("[F I]") == "Fail") == true)
{return "Fail"}
if (($("[V I]") == "Fail") == true)
{return "Fail"}
else
{return ""}`,
context
)
expect(result).toBe("Fail")
})
it("should handle test case 8", async () => {
const context = {
"T L": [{ Hours: 10 }],
"B H": 50,
}
const result = await processJS(
`var totalHours = 0;
if (($("[T L]") != null) == true){
for (let i = 0; i < ($("[T L]").length); i++){
var individualHours = "T L." + i + ".Hours";
var hoursNum = Number($(individualHours));
totalHours += hoursNum;
}
return totalHours.toFixed(2);
}
if (($("[T L]") != null) == false) {
return totalHours.toFixed(2);
}
`,
context
)
expect(result).toBe("10.00")
})
it("should handle test case 9", async () => {
const context = {
"T L": [{ Hours: 10 }],
"B H": 50,
}
const result = await processJS(
`var totalHours = 0;
if (($("[T L]") != null) == true){
for (let i = 0; i < ($("[T L]").length); i++){
var individualHours = "T L." + i + ".Hours";
var hoursNum = Number($(individualHours));
totalHours += hoursNum;
}
return ($("[B H]") - totalHours).toFixed(2);
}
if (($("[T L]") != null) == false) {
return ($("[B H]") - totalHours).toFixed(2);
}`,
context
)
expect(result).toBe("40.00")
})
it("should handle test case 10", async () => {
const context = {
"F F": [{ "F S": 10 }],
}
const result = await processJS(
`var rating = 0;
if ($("[F F]") != null){
for (i = 0; i < $("[F F]").length; i++){
var individualRating = $("F F." + i + ".F S");
rating += individualRating;
}
rating = (rating / $("[F F]").length);
}
return rating;
`,
context
)
expect(result).toBe(10)
})
})
})

3018
packages/server/src/jsRunner/tests/largeJSExample.txt Normal file
View file

File diff suppressed because it is too large Load diff

3
packages/server/src/jsRunner/utilities.ts Normal file
View file

@ -0,0 +1,3 @@
export function iifeWrapper(script: string) {
return `(function(){\n${script}\n})();`
}

11
packages/server/src/jsRunner/vm/isolated-vm.ts
View file

@ -7,6 +7,7 @@ import querystring from "querystring"
import { BundleType, loadBundle } from "../bundles"
import { VM } from "@budibase/types"
import { iifeWrapper } from "../utilities"
import environment from "../../environment"
class ExecutionTimeoutError extends Error {
@ -118,11 +119,11 @@ export class IsolatedVM implements VM {
// 3. Process script
// 4. Stringify the result in order to convert the result from BSON to json
this.codeWrapper = code =>
`(function(){
const data = bson.deserialize(bsonData, { validation: { utf8: false } }).data;
const result = ${code}
return bson.toJson(result);
})();`
iifeWrapper(`
const data = bson.deserialize(bsonData, { validation: { utf8: false } }).data;
const result = ${code}
return bson.toJson(result);
`)
const bsonSource = loadBundle(BundleType.BSON)

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

@ -36,11 +36,13 @@ export async function search(options: SearchParams): Promise<{
export interface ExportRowsParams {
tableId: string
format: Format
delimiter?: string
rowIds?: string[]
columns?: string[]
query?: SearchFilters
sort?: string
sortOrder?: SortOrder
customHeaders?: { [key: string]: string }
}
export interface ExportRowsResult {

21
packages/server/src/sdk/app/rows/search/external.ts
View file

@ -101,7 +101,17 @@ export async function search(options: SearchParams) {
export async function exportRows(
options: ExportRowsParams
): Promise<ExportRowsResult> {
const { tableId, format, columns, rowIds, query, sort, sortOrder } = options
const {
tableId,
format,
columns,
rowIds,
query,
sort,
sortOrder,
delimiter,
customHeaders,
} = options
const { datasourceId, tableName } = breakExternalTableId(tableId)
let requestQuery: SearchFilters = {}
@ -153,12 +163,17 @@ export async function exportRows(
rows = result.rows
}
let exportRows = cleanExportRows(rows, schema, format, columns)
let exportRows = cleanExportRows(rows, schema, format, columns, customHeaders)
let content: string
switch (format) {
case exporters.Format.CSV:
content = exporters.csv(headers ?? Object.keys(schema), exportRows)
content = exporters.csv(
headers ?? Object.keys(schema),
exportRows,
delimiter,
customHeaders
)
break
case exporters.Format.JSON:
content = exporters.json(exportRows)

21
packages/server/src/sdk/app/rows/search/internal.ts
View file

@ -84,7 +84,17 @@ export async function search(options: SearchParams) {
export async function exportRows(
options: ExportRowsParams
): Promise<ExportRowsResult> {
const { tableId, format, rowIds, columns, query, sort, sortOrder } = options
const {
tableId,
format,
rowIds,
columns,
query,
sort,
sortOrder,
delimiter,
customHeaders,
} = options
const db = context.getAppDB()
const table = await sdk.tables.getTable(tableId)
@ -124,11 +134,16 @@ export async function exportRows(
rows = result
}
let exportRows = cleanExportRows(rows, schema, format, columns)
let exportRows = cleanExportRows(rows, schema, format, columns, customHeaders)
if (format === Format.CSV) {
return {
fileName: "export.csv",
content: csv(headers ?? Object.keys(rows[0]), exportRows),
content: csv(
headers ?? Object.keys(rows[0]),
exportRows,
delimiter,
customHeaders
),
}
} else if (format === Format.JSON) {
return {

19
packages/server/src/sdk/app/rows/utils.ts
View file

@ -16,7 +16,8 @@ export function cleanExportRows(
rows: any[],
schema: TableSchema,
format: string,
columns?: string[]
columns?: string[],
customHeaders: { [key: string]: string } = {}
) {
let cleanRows = [...rows]
@ -44,11 +45,27 @@ export function cleanExportRows(
}
}
}
} else if (format === Format.JSON) {
// Replace row keys with custom headers
for (let row of cleanRows) {
renameKeys(customHeaders, row)
}
}
return cleanRows
}
function renameKeys(keysMap: { [key: string]: any }, row: any) {
for (const key in keysMap) {
Object.defineProperty(
row,
keysMap[key],
Object.getOwnPropertyDescriptor(row, key) || {}
)
delete row[key]
}
}
function isForeignKey(key: string, table: Table) {
const relationships = Object.values(table.schema).filter(isRelationshipColumn)
return relationships.some(

173
packages/server/src/tests/utilities/api/application.ts
View file

@ -1,17 +1,96 @@
import { Response } from "supertest"
import { App } from "@budibase/types"
import {
App,
type CreateAppRequest,
type FetchAppDefinitionResponse,
type FetchAppPackageResponse,
} from "@budibase/types"
import TestConfiguration from "../TestConfiguration"
import { TestAPI } from "./base"
import { AppStatus } from "../../../db/utils"
import { constants } from "@budibase/backend-core"
export class ApplicationAPI extends TestAPI {
constructor(config: TestConfiguration) {
super(config)
}
create = async (app: CreateAppRequest): Promise<App> => {
const request = this.request
.post("/api/applications")
.set(this.config.defaultHeaders())
.expect("Content-Type", /json/)
for (const key of Object.keys(app)) {
request.field(key, (app as any)[key])
}
if (app.templateFile) {
request.attach("templateFile", app.templateFile)
}
const result = await request
if (result.statusCode !== 200) {
throw new Error(JSON.stringify(result.body))
}
return result.body as App
}
delete = async (appId: string): Promise<void> => {
await this.request
.delete(`/api/applications/${appId}`)
.set(this.config.defaultHeaders())
.expect(200)
}
publish = async (
appId: string
): Promise<{ _id: string; status: string; appUrl: string }> => {
// While the publish endpoint does take an :appId parameter, it doesn't
// use it. It uses the appId from the context.
let headers = {
...this.config.defaultHeaders(),
[constants.Header.APP_ID]: appId,
}
const result = await this.request
.post(`/api/applications/${appId}/publish`)
.set(headers)
.expect("Content-Type", /json/)
.expect(200)
return result.body as { _id: string; status: string; appUrl: string }
}
unpublish = async (appId: string): Promise<void> => {
await this.request
.post(`/api/applications/${appId}/unpublish`)
.set(this.config.defaultHeaders())
.expect(204)
}
sync = async (
appId: string,
{ statusCode }: { statusCode: number } = { statusCode: 200 }
): Promise<{ message: string }> => {
const result = await this.request
.post(`/api/applications/${appId}/sync`)
.set(this.config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(statusCode)
return result.body
}
getRaw = async (appId: string): Promise<Response> => {
// While the appPackage endpoint does take an :appId parameter, it doesn't
// use it. It uses the appId from the context.
let headers = {
...this.config.defaultHeaders(),
[constants.Header.APP_ID]: appId,
}
const result = await this.request
.get(`/api/applications/${appId}/appPackage`)
.set(this.config.defaultHeaders())
.set(headers)
.expect("Content-Type", /json/)
.expect(200)
return result
@ -21,4 +100,94 @@ export class ApplicationAPI extends TestAPI {
const result = await this.getRaw(appId)
return result.body.application as App
}
getDefinition = async (
appId: string
): Promise<FetchAppDefinitionResponse> => {
const result = await this.request
.get(`/api/applications/${appId}/definition`)
.set(this.config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
return result.body as FetchAppDefinitionResponse
}
getAppPackage = async (appId: string): Promise<FetchAppPackageResponse> => {
const result = await this.request
.get(`/api/applications/${appId}/appPackage`)
.set(this.config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
return result.body
}
update = async (
appId: string,
app: { name?: string; url?: string }
): Promise<App> => {
const request = this.request
.put(`/api/applications/${appId}`)
.set(this.config.defaultHeaders())
.expect("Content-Type", /json/)
for (const key of Object.keys(app)) {
request.field(key, (app as any)[key])
}
const result = await request
if (result.statusCode !== 200) {
throw new Error(JSON.stringify(result.body))
}
return result.body as App
}
updateClient = async (appId: string): Promise<void> => {
// While the updateClient endpoint does take an :appId parameter, it doesn't
// use it. It uses the appId from the context.
let headers = {
...this.config.defaultHeaders(),
[constants.Header.APP_ID]: appId,
}
const response = await this.request
.post(`/api/applications/${appId}/client/update`)
.set(headers)
.expect("Content-Type", /json/)
if (response.statusCode !== 200) {
throw new Error(JSON.stringify(response.body))
}
}
revertClient = async (appId: string): Promise<void> => {
// While the revertClient endpoint does take an :appId parameter, it doesn't
// use it. It uses the appId from the context.
let headers = {
...this.config.defaultHeaders(),
[constants.Header.APP_ID]: appId,
}
const response = await this.request
.post(`/api/applications/${appId}/client/revert`)
.set(headers)
.expect("Content-Type", /json/)
if (response.statusCode !== 200) {
throw new Error(JSON.stringify(response.body))
}
}
fetch = async ({ status }: { status?: AppStatus } = {}): Promise<App[]> => {
let query = []
if (status) {
query.push(`status=${status}`)
}
const result = await this.request
.get(`/api/applications${query.length ? `?${query.join("&")}` : ""}`)
.set(this.config.defaultHeaders())
.expect("Content-Type", /json/)
.expect(200)
return result.body as App[]
}
}

3
packages/server/src/threads/query.ts
View file

@ -8,6 +8,7 @@ import {
QueryResponse,
} from "./definitions"
import { IsolatedVM } from "../jsRunner/vm"
import { iifeWrapper } from "../jsRunner/utilities"
import { getIntegration } from "../integrations"
import { processStringSync } from "@budibase/string-templates"
import { context, cache, auth } from "@budibase/backend-core"
@ -127,7 +128,7 @@ class QueryRunner {
// transform as required
if (transformer) {
transformer = `(function(){\n${transformer}\n})();`
transformer = iifeWrapper(transformer)
let vm = new IsolatedVM()
if (datasource.source === SourceName.MONGODB) {
vm = vm.withParsingBson(rows)

2
packages/types/src/api/web/app/rows.ts
View file

@ -37,6 +37,8 @@ export interface ExportRowsRequest {
query?: SearchFilters
sort?: string
sortOrder?: SortOrder
delimiter?: string
customHeaders?: { [key: string]: string }
}
export type ExportRowsResponse = ReadStream

29
packages/types/src/api/web/application.ts Normal file
View file

@ -0,0 +1,29 @@
import type { PlanType } from "../../sdk"
import type { Layout, App, Screen } from "../../documents"
export interface CreateAppRequest {
name: string
url?: string
useTemplate?: string
templateName?: string
templateKey?: string
templateFile?: string
includeSampleData?: boolean
encryptionPassword?: string
templateString?: string
}
export interface FetchAppDefinitionResponse {
layouts: Layout[]
screens: Screen[]
libraries: string[]
}
export interface FetchAppPackageResponse {
application: App
licenseType: PlanType
screens: Screen[]
layouts: Layout[]
clientLibPath: string
hasLock: boolean
}

1
packages/types/src/api/web/index.ts
View file

@ -1,3 +1,4 @@
export * from "./application"
export * from "./analytics"
export * from "./auth"
export * from "./user"

4
packages/types/src/documents/app/app.ts
View file

@ -1,4 +1,4 @@
import { User, Document } from "../"
import { User, Document, Plugin } from "../"
import { SocketSession } from "../../sdk"
export type AppMetadataErrors = { [key: string]: string[] }
@ -24,6 +24,8 @@ export interface App extends Document {
icon?: AppIcon
features?: AppFeatures
automations?: AutomationSettings
usedPlugins?: Plugin[]
upgradableVersion?: string
}
export interface AppInstance {

8
packages/worker/scripts/test.sh
View file

@ -4,10 +4,10 @@ set -e
if [[ -n $CI ]]
then
# Running in ci, where resources are limited
echo "jest --coverage --maxWorkers=2 --forceExit --bail"
jest --coverage --maxWorkers=2 --forceExit --bail
echo "jest --coverage --maxWorkers=2 --forceExit --bail $@"
jest --coverage --maxWorkers=2 --forceExit --bail $@
else
# --maxWorkers performs better in development
echo "jest --coverage --maxWorkers=2 --forceExit"
jest --coverage --maxWorkers=2 --forceExit
echo "jest --coverage --maxWorkers=2 --forceExit $@"
jest --coverage --maxWorkers=2 --forceExit $@
fi

3
qa-core/src/internal-api/api/apis/AppAPI.ts
View file

@ -1,11 +1,10 @@
import { App } from "@budibase/types"
import { App, CreateAppRequest } from "@budibase/types"
import { Response } from "node-fetch"
import {
RouteConfig,
AppPackageResponse,
DeployConfig,
MessageResponse,
CreateAppRequest,
} from "../../../types"
import BudibaseInternalAPIClient from "../BudibaseInternalAPIClient"
import BaseAPI from "./BaseAPI"

2
qa-core/src/internal-api/fixtures/applications.ts
View file

@ -1,5 +1,5 @@
import { generator } from "../../shared"
import { CreateAppRequest } from "../../types"
import { CreateAppRequest } from "@budibase/types"
function uniqueWord() {
return generator.word() + generator.hash()

11
qa-core/src/internal-api/tests/tables/tables.spec.ts
View file

@ -13,17 +13,6 @@ describe("Internal API - Table Operations", () => {
await config.afterAll()
})
async function createAppFromTemplate() {
return config.api.apps.create({
name: generator.word(),
url: `/${generator.word()}`,
useTemplate: "true",
templateName: "Near Miss Register",
templateKey: "app/near-miss-register",
templateFile: undefined,
})
}
it("Create and delete table, columns and rows", async () => {
// create the app
await config.createApp(fixtures.apps.appFromTemplate())

4
qa-core/src/shared/BudibaseTestConfiguration.ts
View file

@ -1,8 +1,8 @@
import { BudibaseInternalAPI } from "../internal-api"
import { AccountInternalAPI } from "../account-api"
import { APIRequestOpts, CreateAppRequest, State } from "../types"
import { APIRequestOpts, State } from "../types"
import * as fixtures from "../internal-api/fixtures"
import { CreateAccountRequest } from "@budibase/types"
import { CreateAccountRequest, CreateAppRequest } from "@budibase/types"
export default class BudibaseTestConfiguration {
// apis

10
qa-core/src/types/app.ts
View file

@ -1,10 +0,0 @@
// TODO: Integrate with budibase
export interface CreateAppRequest {
name: string
url: string
useTemplate?: string
templateName?: string
templateKey?: string
templateFile?: string
includeSampleData?: boolean
}

1
qa-core/src/types/index.ts
View file

@ -1,6 +1,5 @@
export * from "./api"
export * from "./apiKeyResponse"
export * from "./app"
export * from "./appPackage"
export * from "./deploy"
export * from "./newAccount"

15
yarn.lock
View file

@ -3902,19 +3902,6 @@
magic-string "^0.25.7"
resolve "^1.17.0"
"@rollup/plugin-commonjs@^18.0.0":
version "18.1.0"
resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-18.1.0.tgz#5a760d757af168a50727c0ae080251fbfcc5eb02"
integrity sha512-h3e6T9rUxVMAQswpDIobfUHn/doMzM9sgkMrsMWCFLmB84PSoC8mV8tOloAJjSRwdqhXBqstlX2BwBpHJvbhxg==
dependencies:
"@rollup/pluginutils" "^3.1.0"
commondir "^1.0.1"
estree-walker "^2.0.1"
glob "^7.1.6"
is-reference "^1.2.1"
magic-string "^0.25.7"
resolve "^1.17.0"
"@rollup/plugin-commonjs@^25.0.7":
version "25.0.7"
resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-25.0.7.tgz#145cec7589ad952171aeb6a585bbeabd0fd3b4cf"
@ -19257,7 +19244,7 @@ rollup@2.45.2:
optionalDependencies:
fsevents "~2.3.1"
rollup@^2.36.2, rollup@^2.44.0, rollup@^2.45.2:
rollup@^2.36.2, rollup@^2.45.2:
version "2.79.1"
resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.79.1.tgz#bedee8faef7c9f93a2647ac0108748f497f081c7"
integrity sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==