preserve project fixes from earlier merge resolutions

Author: andz-bb

packages/builder/src/components/integration/APIEndpointViewer.svelte

@@ -27,12 +27,10 @@
     notifications,
     Banner,
     Divider,
-    Label,
     Switcher,
   } from "@budibase/bbui"
   import {
     BodyType,
-    FeatureFlag,
     type Query,
     type Datasource,
     type ImportEndpoint,
@@ -87,14 +85,13 @@
   import ExpandablePanel from "@/components/common/ExpandablePanel.svelte"
   import ConnectionSelect from "./rest/ConnectionSelect.svelte"
   import AccessLevelSelect from "@/components/integration/AccessLevelSelect.svelte"
-  import ProjectSelect from "@/components/common/ProjectSelect.svelte"
   import { getErrorMessage } from "@/helpers/errors"
   import { confirm } from "@/helpers"
   import {
     urlParamHighlightPlugin,
     urlParamHighlightTheme,
   } from "../common/CodeEditor/urlParamHighlight"
-  import { environment, featureFlags } from "@/stores/portal"
+  import { environment } from "@/stores/portal"
   import { workspaceConnections } from "@/stores/builder/workspaceConnection"
   import { onDestroy, onMount, createEventDispatcher } from "svelte"
 
@@ -109,11 +106,9 @@
   export let connectionPopoverPortalTarget: string | undefined = undefined
   export let connectionPopoverZIndex: number | undefined = undefined
   export let openAddConnectionOnMount: boolean = false
-  export let initialProjectIds: string[] = []
 
   $beforeUrlChange
   $: goto = $gotoStore
-  $: projectsEnabled = $featureFlags[FeatureFlag.PROJECTS]
 
   type EndpointWithIcon = ImportEndpoint & {
     icon?: {
@@ -141,8 +136,6 @@
   let response: PreviewQueryResponse
   let panelMode: "response" | "request" = "response"
   let editableQuery: Query | undefined
-  let projectIds: string[] = []
-  let originalProjectIds: string[] = []
   let datasource: Datasource | UIInternalDatasource | undefined
   let enabledHeaders: Record<string, boolean> = {}
   let globalDynamicRequestBindings: EnrichedBinding[] = []
@@ -221,12 +214,6 @@
 
   $: if (querySourceKey !== lastQuerySourceKey) {
     editableQuery = structuredClone(storeQuery)
-    projectIds =
-      editableQuery?.projectIds ||
-      (!editableQuery?._id && initialProjectIds.length
-        ? [...initialProjectIds]
-        : [])
-    originalProjectIds = [...projectIds]
     lastQuerySourceKey = querySourceKey
     queryParams = undefined
     originalBuiltQuery = undefined
@@ -335,14 +322,18 @@
     ? prettifyQueryRequestBody(editableQuery, mergedBindings)
     : undefined
 
+  const stripQueryProjectIds = (query: Query): Query => {
+    const { projectIds: _projectIds, ...queryWithoutProjectIds } = query
+    return queryWithoutProjectIds
+  }
+
   // ── BUILT QUERY & DIRTY STATE ─────────────────────────────────────────────
   $: builtQuery =
     editableQuery &&
     schema &&
     buildQuery(
       {
-        ...editableQuery,
-        projectIds: getQueryProjectIds(),
+        ...stripQueryProjectIds(editableQuery),
         datasourceId: selectedDatasourceId || editableQuery.datasourceId,
         fields: { ...editableQuery.fields, path: requestUrl },
       },
@@ -452,13 +443,6 @@
     ds: Datasource | UIInternalDatasource | undefined
   ): string | undefined => (ds as Datasource)?.config?.url as string | undefined
 
-  const getQueryProjectIds = () => {
-    if (projectIds.length) {
-      return projectIds
-    }
-    return !isNewQuery && originalProjectIds.length ? [] : undefined
-  }
-
   const resolveStoreQuery = (
     list: Query[] | undefined,
     qId: string | undefined,
@@ -708,8 +692,6 @@
       }
 
       editableQuery = structuredClone(updatedQuery)
-      projectIds = updatedQuery.projectIds || []
-      originalProjectIds = [...projectIds]
       originalBuiltQuery = undefined
       localDynamicVariables = undefined
 
@@ -1079,12 +1061,6 @@
             <div class="access">
               <AccessLevelSelect query={editableQuery} label="Access" />
             </div>
-            {#if projectsEnabled}
-              <div class="project">
-                <Label>Projects</Label>
-                <ProjectSelect bind:value={projectIds} label="" autoWidth />
-              </div>
-            {/if}
           {/if}
           {#if endpointDocs}
             <ActionButton
@@ -1646,11 +1622,6 @@
     align-items: center;
     gap: var(--spacing-m);
   }
-  .project {
-    display: flex;
-    align-items: center;
-    gap: var(--spacing-m);
-  }
   .pagination {
     display: grid;
     grid-template-columns: 1fr 1fr;

packages/server/src/api/routes/tests/project.spec.ts

@@ -1,6 +1,7 @@
 import {
   context,
   db as dbCore,
+  encryption,
   features,
   ViewName,
 } from "@budibase/backend-core"

packages/server/src/api/routes/tests/projectOwnerOmission.spec.ts

@@ -0,0 +1,90 @@
+import { context, features } from "@budibase/backend-core"
+import { FeatureFlag } from "@budibase/types"
+import TestConfiguration from "../../../tests/utilities/TestConfiguration"
+import {
+  basicDatasource,
+  basicQuery,
+  basicTable,
+  createQueryScreen,
+  createViewScreen,
+} from "../../../tests/utilities/structures"
+
+describe("Project package ownership", () => {
+  const config = new TestConfiguration()
+
+  beforeEach(async () => config.newTenant())
+  afterAll(() => config.end())
+
+  it("imports an app after its query datasource was excluded from assignment", async () => {
+    await features.testutils.withFeatureFlags(
+      config.getTenantId(),
+      { [FeatureFlag.PROJECTS]: true },
+      async () => {
+        const { project } = await config.api.project.create({ name: "Support" })
+        const datasource = await config.api.datasource.create(
+          basicDatasource().datasource
+        )
+        const query = await config.api.query.save(basicQuery(datasource._id!))
+        const { workspaceApp } = await config.api.workspaceApp.create({
+          name: "Support app",
+          url: "/support",
+        })
+        await config.api.screen.save({
+          ...createQueryScreen(datasource._id!, query),
+          workspaceAppId: workspaceApp._id,
+        })
+        await config.doInContext(config.getDevWorkspaceId(), async () => {
+          await context.getWorkspaceDB().put({
+            ...workspaceApp,
+            projectIds: [project._id],
+          })
+        })
+
+        const archive = await config.api.project.export(project._id)
+        const imported = await config.api.project.import(archive)
+
+        expect(imported.resources.workspace_app).toHaveLength(1)
+        expect(imported.resources.query).toBeUndefined()
+        expect(imported.resources.datasource).toBeUndefined()
+      }
+    )
+  })
+
+  it("imports an app after its row action table was excluded from assignment", async () => {
+    await features.testutils.withFeatureFlags(
+      config.getTenantId(),
+      { [FeatureFlag.PROJECTS]: true },
+      async () => {
+        const { project } = await config.api.project.create({ name: "Support" })
+        const table = await config.api.table.save(basicTable())
+        await config.api.rowAction.save(table._id!, { name: "Approve" })
+        const view = await config.api.viewV2.create({
+          tableId: table._id!,
+          name: "Open tickets",
+        })
+        const { workspaceApp } = await config.api.workspaceApp.create({
+          name: "Support app",
+          url: "/support",
+        })
+        await config.api.screen.save({
+          ...createViewScreen(view),
+          workspaceAppId: workspaceApp._id,
+        })
+        await config.doInContext(config.getDevWorkspaceId(), async () => {
+          await context.getWorkspaceDB().put({
+            ...workspaceApp,
+            projectIds: [project._id],
+          })
+        })
+
+        const archive = await config.api.project.export(project._id)
+        const imported = await config.api.project.import(archive)
+
+        expect(imported.resources.workspace_app).toHaveLength(1)
+        expect(imported.resources.row_action).toBeUndefined()
+        expect(imported.resources.table).toBeUndefined()
+        expect(imported.resources.automation).toBeUndefined()
+      }
+    )
+  })
+})

packages/server/src/sdk/workspace/backups/imports.ts

@@ -156,7 +156,11 @@ export async function untarFile(file: { path: string }) {
   return tmpPath
 }
 
-export async function decryptFiles(path: string, password: string) {
+export async function decryptFiles(
+  path: string,
+  password: string,
+  { maxOutputBytes = Infinity }: { maxOutputBytes?: number } = {}
+) {
   try {
     const processDirectory = async (dirPath: string) => {
       for (let file of await fsp.readdir(dirPath)) {
@@ -165,7 +169,10 @@ export async function decryptFiles(path: string, password: string) {
           const stats = await fsp.lstat(inputPath)
           if (stats.isFile() && inputPath.endsWith(".enc")) {
             const outputPath = inputPath.replace(/\.enc$/, "")
-            await encryption.decryptFile(inputPath, outputPath, password)
+            await encryption.decryptFile(inputPath, outputPath, password, {
+              maxOutputBytes,
+            })
+            maxOutputBytes -= (await fsp.stat(outputPath)).size
             await fsp.rm(inputPath)
           } else if (stats.isDirectory()) {
             await processDirectory(inputPath)

packages/server/src/sdk/workspace/projects/backups/constants.ts

@@ -4,3 +4,6 @@ export const PROJECT_FILE = "project.json"
 export const PROJECT_DEPENDENCY_INDEX_FILE = "dependency-index.json"
 export const PROJECT_DOCS_DIRECTORY = "docs"
 export const PROJECT_ATTACHMENTS_DIRECTORY = "attachments"
+export const MAX_PROJECT_ARCHIVE_SIZE_BYTES = 50 * 1024 * 1024
+export const MAX_PROJECT_EXTRACTED_SIZE_BYTES = 100 * 1024 * 1024
+export const MAX_PROJECT_PACKAGE_FILES = 2000

packages/server/src/sdk/workspace/projects/backups/exports.ts

@@ -1,4 +1,4 @@
-import { context, encryption } from "@budibase/backend-core"
+import { context, encryption, HTTPError } from "@budibase/backend-core"
 import {
   Agent,
   AnyDocument,
@@ -29,13 +29,15 @@ import {
   isDisallowedProjectAssignmentResourceId,
 } from "../../resources/utils"
 import {
+  MAX_PROJECT_ARCHIVE_SIZE_BYTES,
   PROJECT_ATTACHMENTS_DIRECTORY,
   PROJECT_DEPENDENCY_INDEX_FILE,
   PROJECT_DOCS_DIRECTORY,
   PROJECT_EXPORT_FORMAT_VERSION,
   PROJECT_FILE,
   PROJECT_MANIFEST_FILE,
 } from "./constants"
+import { readProjectPackageFiles } from "./files"
 import { doWithProjectAssignmentsLock } from "../lock"
 import {
   fetchAssignedProjectDocs,
@@ -514,11 +516,18 @@ export async function exportProject(
       throw writeFailure.reason
     }
 
+    await readProjectPackageFiles({ dirPath: tmpPath })
+
     if (opts?.encryptPassword) {
       await encryptDirectory(tmpPath, opts.encryptPassword)
     }
 
-    return await tarFilesToTmp(tmpPath, await fsp.readdir(tmpPath))
+    const tarPath = await tarFilesToTmp(tmpPath, await fsp.readdir(tmpPath))
+    if ((await fsp.stat(tarPath)).size > MAX_PROJECT_ARCHIVE_SIZE_BYTES) {
+      await fsp.rm(tarPath, { force: true })
+      throw new HTTPError("Project package is too large.", 400)
+    }
+    return tarPath
   } finally {
     await fsp.rm(tmpPath, { recursive: true, force: true })
   }

packages/server/src/sdk/workspace/projects/backups/files.ts

@@ -0,0 +1,71 @@
+import { HTTPError } from "@budibase/backend-core"
+import fsp from "fs/promises"
+import { join, relative } from "path"
+import {
+  MAX_PROJECT_EXTRACTED_SIZE_BYTES,
+  MAX_PROJECT_PACKAGE_FILES,
+} from "./constants"
+
+export const MAX_PROJECT_PATH_SEGMENTS = 4
+
+export const isSafeArchivePath = (path: string) => {
+  const segments = path.split(/[\\/]/)
+  return (
+    !path.startsWith("/") &&
+    !path.startsWith("\\") &&
+    !/^[A-Za-z]:/.test(path) &&
+    segments.every(segment => segment !== ".." && segment !== ".")
+  )
+}
+
+export const readProjectPackageFiles = async ({
+  dirPath,
+  rootPath = dirPath,
+  totals = { files: 0, bytes: 0 },
+}: {
+  dirPath: string
+  rootPath?: string
+  totals?: { files: number; bytes: number }
+}): Promise<string[]> => {
+  const entries = await fsp.readdir(dirPath, { withFileTypes: true })
+  const files: string[] = []
+
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry.name)
+    const relPath = relative(rootPath, fullPath)
+    if (!isSafeArchivePath(relPath)) {
+      throw new HTTPError("Project package contains unsafe paths.", 400)
+    }
+    if (relPath.split(/[\\/]/).length > MAX_PROJECT_PATH_SEGMENTS) {
+      throw new HTTPError(
+        "Project package contains paths that are too deep.",
+        400
+      )
+    }
+    if (entry.isSymbolicLink()) {
+      throw new HTTPError("Project package contains unsupported links.", 400)
+    }
+    if (entry.isDirectory()) {
+      files.push(
+        ...(await readProjectPackageFiles({
+          dirPath: fullPath,
+          rootPath,
+          totals,
+        }))
+      )
+    } else {
+      const stats = await fsp.stat(fullPath)
+      totals.files += 1
+      totals.bytes += stats.size
+      if (totals.files > MAX_PROJECT_PACKAGE_FILES) {
+        throw new HTTPError("Project package contains too many files.", 400)
+      }
+      if (totals.bytes > MAX_PROJECT_EXTRACTED_SIZE_BYTES) {
+        throw new HTTPError("Project package is too large.", 400)
+      }
+      files.push(fullPath)
+    }
+  }
+
+  return files
+}