@synchronized-console/shared 2.25.7 → 2.31.14

package/src/environment/index.spec.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect, afterEach, beforeEach } from 'vitest'
+import { parseFeatureFlags } from './index.js'
+import { FeatureFlags } from './featureFlags.js'
+
+const originalDisableAllFfs = process.env.DISABLE_ALL_FFS || ''
+const originalEnableAllFfs = process.env.ENABLE_ALL_FFS || ''
+
+const setDisableAllFfs = (value: boolean) => {
+  process.env.DISABLE_ALL_FFS = value.toString()
+}
+
+const setEnableAllFfs = (value: boolean) => {
+  process.env.ENABLE_ALL_FFS = value.toString()
+}
+
+const resetEnv = () => {
+  process.env.DISABLE_ALL_FFS = originalDisableAllFfs
+  process.env.ENABLE_ALL_FFS = originalEnableAllFfs
+}
+
+describe('parseFeatureFlags', () => {
+  beforeEach(() => {
+    // Disable global "ALL FFs"/"NO FFs" modes for these tests, cause they break em
+    setDisableAllFfs(false)
+    setEnableAllFfs(false)
+  })
+
+  afterEach(() => {
+    resetEnv()
+  })
+
+  it('returns all defaults as false', () => {
+    const flags = parseFeatureFlags({})
+    for (const key of Object.keys(flags)) {
+      expect(flags[key as keyof FeatureFlags]).toBe(false)
+    }
+  })
+
+  it('parses explicit true/false values', () => {
+    const flags = parseFeatureFlags({
+      FF_AUTOMATE_MODULE_ENABLED: 'true',
+      FF_GENDOAI_MODULE_ENABLED: 'false',
+      FF_SAVED_VIEWS_ENABLED: 'true'
+    })
+    expect(flags.FF_AUTOMATE_MODULE_ENABLED).toBe(true)
+    expect(flags.FF_GENDOAI_MODULE_ENABLED).toBe(false)
+    expect(flags.FF_SAVED_VIEWS_ENABLED).toBe(true)
+  })
+
+  it('DISABLE_ALL_FFS disables all flags unless forceInputs is true', () => {
+    setDisableAllFfs(true)
+    const flags = parseFeatureFlags(
+      {
+        FF_AUTOMATE_MODULE_ENABLED: 'true',
+        FF_SAVED_VIEWS_ENABLED: 'true'
+      },
+      { forceInputs: false }
+    )
+    for (const key of Object.keys(flags)) {
+      expect(flags[key as keyof FeatureFlags]).toBe(false)
+    }
+  })
+
+  it('ENABLE_ALL_FFS enables all flags unless forceInputs is true', () => {
+    setEnableAllFfs(true)
+    const flags = parseFeatureFlags(
+      {
+        FF_AUTOMATE_MODULE_ENABLED: 'false',
+        FF_SAVED_VIEWS_ENABLED: 'false'
+      },
+      { forceInputs: false }
+    )
+    for (const key of Object.keys(flags)) {
+      expect(flags[key as keyof FeatureFlags]).toBe(true)
+    }
+  })
+
+  it('forceInputs=true preserves explicit input values even with DISABLE_ALL_FFS', () => {
+    setDisableAllFfs(true)
+    const flags = parseFeatureFlags(
+      {
+        FF_AUTOMATE_MODULE_ENABLED: 'true',
+        FF_SAVED_VIEWS_ENABLED: 'false'
+      },
+      { forceInputs: true }
+    )
+
+    expect(flags.FF_AUTOMATE_MODULE_ENABLED).toBe(true)
+    expect(flags.FF_SAVED_VIEWS_ENABLED).toBe(false)
+    // All others should be false
+    for (const key of Object.keys(flags)) {
+      if (key !== 'FF_AUTOMATE_MODULE_ENABLED' && key !== 'FF_SAVED_VIEWS_ENABLED') {
+        expect(flags[key as keyof FeatureFlags]).toBe(false)
+      }
+    }
+  })
+
+  it('forceInputs=true preserves explicit input values even with ENABLE_ALL_FFS', () => {
+    setEnableAllFfs(true)
+    const flags = parseFeatureFlags(
+      {
+        FF_AUTOMATE_MODULE_ENABLED: 'false',
+        FF_SAVED_VIEWS_ENABLED: 'true'
+      },
+      { forceInputs: true }
+    )
+
+    expect(flags.FF_AUTOMATE_MODULE_ENABLED).toBe(false)
+    expect(flags.FF_SAVED_VIEWS_ENABLED).toBe(true)
+    // All others should be true
+    for (const key of Object.keys(flags)) {
+      if (key !== 'FF_AUTOMATE_MODULE_ENABLED' && key !== 'FF_SAVED_VIEWS_ENABLED') {
+        expect(flags[key as keyof FeatureFlags]).toBe(true)
+      }
+    }
+  })
+
+  it('it can handle empty string env vars', () => {
+    const flags = parseFeatureFlags({
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      FF_AUTOMATE_MODULE_ENABLED: ''
+    })
+    expect(flags.FF_AUTOMATE_MODULE_ENABLED).toBe(false)
+  })
+})

package/src/environment/index.ts

@@ -1,6 +1,7 @@
 import { has } from '#lodash'
 import { parseEnv } from 'znv'
 import { z } from 'zod'
+import { FeatureFlags } from './featureFlags.js'
 
 // Convenience variable to override below individual feature flags, which has the effect of setting all to 'false' (disabled)
 // Takes precedence over ENABLE_ALL_FFS
@@ -17,7 +18,7 @@ export const parseFeatureFlags = (
   input: Partial<Record<keyof FeatureFlags, 'true' | 'false' | undefined>>,
   options?: Partial<{
     /**
-     * Whether to prevent inputs from being overriden by disable/enable all
+     * Whether to prevent inputs from being overridden by disable/enable all
      * Default: true
      */
     forceInputs: boolean
@@ -25,10 +26,19 @@ export const parseFeatureFlags = (
 ): FeatureFlags => {
   const { forceInputs = true } = options || {}
 
+  // Clean up input: unset empty values
+  for (const key of Object.keys(input)) {
+    const typedKey = key as keyof FeatureFlags
+    const typedVal = input[typedKey] as unknown
+
+    if (typedVal === undefined || typedVal === '') {
+      delete input[typedKey]
+    }
+  }
+
   //INFO
   // As a convention all feature flags should be prefixed with a FF_
   const res = parseEnv(input, {
-    // Enables the automate module.
     FF_AUTOMATE_MODULE_ENABLED: {
       schema: z.boolean(),
       description:
@@ -40,7 +50,6 @@ export const parseFeatureFlags = (
       description: 'Enables the gendo ai integration',
       defaults: { _: false }
     },
-    //
     FF_WORKSPACES_MODULE_ENABLED: {
       schema: z.boolean(),
       description:
@@ -78,7 +87,6 @@ export const parseFeatureFlags = (
         'Enables workspaces multi region DB support. Requires FF_GATEKEEPER_MODULE_ENABLED and FF_WORKSPACES_MODULE_ENABLED to be true. This requires a valid Synchronized Enterprise Edition license in order to be enabled.  See https://github.com/KingDaryush1/synchronized-server?tab=License-1-ov-file#readme',
       defaults: { _: false }
     },
-    // Forces onboarding for all users
     FF_FORCE_ONBOARDING: {
       schema: z.boolean(),
       description: 'Forces onboarding flow for all users',
@@ -89,25 +97,59 @@ export const parseFeatureFlags = (
       description: 'Enable to not allow personal emails',
       defaults: { _: false }
     },
-    //
     FF_MOVE_PROJECT_REGION_ENABLED: {
       schema: z.boolean(),
       description:
         "Enables endpoint(s) for updating a project's region. Requires FF_WORKSPACES_MULTI_REGION_ENABLED to be true (which indirectly requires FF_GATEKEEPER_MODULE_ENABLED and FF_WORKSPACES_MODULE_ENABLED to be true. This requires a valid Synchronized Enterprise Edition license in order to be enabled, see https://github.com/KingDaryush1/synchronized-server?tab=License-1-ov-file#readme",
       defaults: { _: false }
     },
-    // Enable limits on personal projects
     FF_PERSONAL_PROJECTS_LIMITS_ENABLED: {
       schema: z.boolean(),
-      description:
-        'Enables limits on personal projects. Requires FF_GATEKEEPER_MODULE_ENABLED and FF_WORKSPACES_MODULE_ENABLED to be true. This requires a valid Synchronized Enterprise Edition license in order to be enabled, see https://github.com/KingDaryush1/synchronized-server?tab=License-1-ov-file#readme',
       defaults: { _: false }
     },
-    // Enables the new file importer
+    // Enables retrying errored previews
+    FF_RETRY_ERRORED_PREVIEWS_ENABLED: {
+      schema: z.boolean(),
+      description: 'Allows the retrying of previews which have previously failed.',
+      defaults: { _: false }
+    },
     FF_NEXT_GEN_FILE_IMPORTER_ENABLED: {
       schema: z.boolean(),
       description: 'Enables the new file importer.',
       defaults: { _: false }
+    },
+    FF_RHINO_FILE_IMPORTER_ENABLED: {
+      schema: z.boolean(),
+      description: 'Enables the Rhino based file importer.',
+      defaults: { _: false }
+    },
+    FF_LEGACY_FILE_IMPORTS_ENABLED: {
+      schema: z.boolean(),
+      description:
+        'Enables the legacy file importer. This proxies file uploads via REST API on the server instead of directly PUTing files to S3 via pre-signed urls.',
+      defaults: { _: false }
+    },
+    FF_ACC_INTEGRATION_ENABLED: {
+      schema: z.boolean(),
+      description:
+        'Enables the integration with ACC. This synchronizes models with specified ACC assets.',
+      defaults: { _: false }
+    },
+    FF_DASHBOARDS_MODULE_ENABLED: {
+      schema: z.boolean(),
+      description: 'Enables the dashboards module.',
+      defaults: { _: false }
+    },
+    FF_SAVED_VIEWS_ENABLED: {
+      schema: z.boolean(),
+      description: 'Enables the saved views feature for project models',
+      defaults: { _: false }
+    },
+    FF_USERS_INVITE_SCOPE_IS_PUBLIC: {
+      schema: z.boolean(),
+      description:
+        'Enables Personal Access Tokens (PAT) to be created with users:invite scope. **WARNING** This can be used to spam invitations to any email address. It is not advised to enable this on servers which are open to public account registration or to which untrusted users have been, or can be, invited.',
+      defaults: { _: false }
     }
   })
 
@@ -127,21 +169,6 @@ export const parseFeatureFlags = (
 
 let parsedFlags: FeatureFlags | undefined
 
-export type FeatureFlags = {
-  FF_AUTOMATE_MODULE_ENABLED: boolean
-  FF_GENDOAI_MODULE_ENABLED: boolean
-  FF_WORKSPACES_MODULE_ENABLED: boolean
-  FF_WORKSPACES_SSO_ENABLED: boolean
-  FF_GATEKEEPER_MODULE_ENABLED: boolean
-  FF_BILLING_INTEGRATION_ENABLED: boolean
-  FF_WORKSPACES_MULTI_REGION_ENABLED: boolean
-  FF_FORCE_ONBOARDING: boolean
-  FF_MOVE_PROJECT_REGION_ENABLED: boolean
-  FF_NO_PERSONAL_EMAILS_ENABLED: boolean
-  FF_PERSONAL_PROJECTS_LIMITS_ENABLED: boolean
-  FF_NEXT_GEN_FILE_IMPORTER_ENABLED: boolean
-}
-
 export function getFeatureFlags(): FeatureFlags {
   //@ts-expect-error this way, the parse function typing is a lot better
   if (!parsedFlags) parsedFlags = parseFeatureFlags(process.env, { forceInputs: false })

package/src/environment/node.ts

@@ -0,0 +1,11 @@
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+/**
+ * Feed in import.meta and get the module's filesystem location
+ */
+export const getModuleDirectory = (meta: ImportMeta): string => {
+  const __filename = fileURLToPath(meta.url)
+  const __dirname = dirname(__filename)
+  return __dirname
+}

package/src/images/base64.spec.ts

@@ -0,0 +1,42 @@
+import { isValidBase64Image } from './base64.js'
+import { describe, it, expect } from 'vitest'
+
+describe('isValidBase64Image', () => {
+  it('returns true for a valid base64 PNG image', () => {
+    const validPng = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA'
+    expect(isValidBase64Image(validPng)).toBe(true)
+  })
+
+  it('returns true for a valid base64 JPEG image', () => {
+    const validJpeg = 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD'
+    expect(isValidBase64Image(validJpeg)).toBe(true)
+  })
+
+  it('returns false if string does not start with data:image/', () => {
+    const invalid = 'data:text/plain;base64,SGVsbG8gd29ybGQ='
+    expect(isValidBase64Image(invalid)).toBe(false)
+  })
+
+  it('returns false if there is no comma separator', () => {
+    const invalid = 'data:image/png;base64iVBORw0KGgoAAAANSUhEUgAAAAUA'
+    expect(isValidBase64Image(invalid)).toBe(false)
+  })
+
+  it('returns false if base64 part is invalid', () => {
+    const invalid = 'data:image/png;base64,not_base64!'
+    expect(isValidBase64Image(invalid)).toBe(false)
+  })
+
+  it('returns false for empty string', () => {
+    expect(isValidBase64Image('')).toBe(false)
+  })
+
+  it('returns false for data:image/ with empty base64', () => {
+    expect(isValidBase64Image('data:image/png;base64,')).toBe(false)
+  })
+
+  it('returns true for valid base64 with whitespace', () => {
+    const validWithWhitespace = 'data:image/png;base64,iVBOR w0KGgoA AAANSUhEUgAAAAUA'
+    expect(isValidBase64Image(validWithWhitespace)).toBe(true)
+  })
+})

package/src/images/base64.ts

@@ -0,0 +1,15 @@
+export const isValidBase64Image = (data: string): boolean => {
+  if (!data.startsWith('data:image/')) return false
+
+  const parts = data.split(',')
+  if (parts.length !== 2) return false
+
+  // Remove all whitespace characters from base64 string
+  const base64String = parts[1].replace(/\s+/g, '')
+
+  // Validate that the cleaned string only has valid base64 characters
+  const base64Regex = /^[A-Za-z0-9+/]+={0,2}$/
+  if (!base64Regex.test(base64String)) return false
+
+  return true
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+/** TODO: We should get rid of the index barrel file at some point entirely and exclusively rely on exports maps */
 export * as RichTextEditor from './rich-text-editor/index.js'
 export * as SynchronizedViewer from './viewer/index.js'
 export * as Automate from './automate/index.js'

package/src/observability/index.ts

@@ -12,6 +12,9 @@ type LogFormatter = (logObject: Record<string, unknown>) => Record<string, unkno
 const allowPrettyDebugger = ['1', 'true'].includes(
   process.env.ALLOW_PRETTY_DEBUGGER || 'false'
 )
+const debugNamespaces = (process.env.LOG_FILTER || '')
+  .split(',')
+  .filter((s) => !!s?.length)
 
 const defaultLevelFormatterFactory =
   (pretty: boolean): LogLevelFormatter =>
@@ -42,7 +45,23 @@ export function getLogger(
     messageKey: pretty ? 'msg' : '@mt',
     level: minimumLoggedLevel,
     // when not pretty, we need the time in the clef appropriate field, not from pino
-    timestamp: pretty ? pino.stdTimeFunctions.isoTime : false
+    timestamp: pretty ? pino.stdTimeFunctions.isoTime : false,
+    hooks: {
+      logMethod(args, method) {
+        // Invoke as is
+        if (!debugNamespaces.length) {
+          return method.apply(this, args)
+        }
+
+        // Filter out if component not in allowed debug namespaces
+        const component = (this.bindings() as { component: string }).component
+        if (debugNamespaces.includes(component)) {
+          return method.apply(this, args)
+        }
+
+        // Otherwise, skip actually logging
+      }
+    }
   }
 
   // pino-pretty hangs in debugger mode in node 22 for some (Ubuntu/WSL2?), dunno why
@@ -52,7 +71,7 @@ export function getLogger(
       options: {
         colorize: true,
         destination: 2, //stderr
-        ignore: 'time',
+        // ignore: 'time',
         levelFirst: true,
         singleLine: true
       }
@@ -60,6 +79,7 @@ export function getLogger(
   }
 
   logger = pino(pinoOptions)
+
   return logger
 }
 

package/src/queue/config.ts

@@ -2,12 +2,14 @@ import Bull from 'bull'
 import { Redis } from 'ioredis'
 import { isRedisReady } from '../redis/isRedisReady.js'
 
-// we're caching this here, so that there is one client for the app lifecycle
-
 type ClientCache = Record<string, { client?: Redis; subscriber?: Redis }>
 
+// we're caching this here, so that there is one client for the app lifecycle
 const clientCache: ClientCache = {}
 
+// so we can get all active queues for monitoring
+const queueCache: Record<string, Bull.Queue> = {}
+
 export const initializeQueue = async <T>({
   queueName,
   redisUrl,
@@ -57,13 +59,23 @@ export const initializeQueue = async <T>({
       }
     }
   }
+
   const newQueue = new Bull<T>(queueName, opts)
-  // bull does not check if redis is ready...
-  //
-  // logger.info('Checking Redis connection is ready...')
+  queueCache[queueName] = newQueue
+
+  // When newQueue closed, remove from cache
+  newQueue.on('close', () => {
+    delete queueCache[queueName]
+  })
+  newQueue.client.on('end', () => {
+    delete queueCache[queueName]
+  })
+
   if (!clientCache[redisUrl].client)
     throw new Error('Redis client not properly initialized')
+
   await isRedisReady(clientCache[redisUrl].client)
-  // await isRedisReady(clientCache[redisUrl].subscriber)
   return await newQueue.isReady()
 }
+
+export const getActiveQueues = () => ({ ...queueCache })

package/src/rich-text-editor/helpers/index.ts

@@ -1,7 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { trim, isNumber } from '#lodash'
-import type { JSONContent } from '@tiptap/core'
 import type { Optional } from '../../core/helpers/utilityTypes.js'
 
+// TODO: had to copy out of tiptap/core, because of a build issue w/ a type-only import from CJS
+type JSONContent = {
+  [key: string]: any
+  type?: string | undefined
+  attrs?: Record<string, any> | undefined
+  content?: JSONContent[]
+  marks?: {
+    type: string
+    attrs?: Record<string, any>
+    [key: string]: any
+  }[]
+  text?: string
+}
+
 /**
  * Used to match URLs that can appear anywhere in a string, not perfect, but crafting a perfect
  * URL regex is quite complex and we only need this for legacy comments

package/src/saved-views/helpers/defaultGroup.spec.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest'
+import { isUngroupedGroup } from './defaultGroup.js'
+
+describe('isUngroupedGroup', () => {
+  it('should return true for ungrouped groups', () => {
+    expect(isUngroupedGroup('default-group')).toBe(true)
+  })
+
+  it('should return false for grouped groups', () => {
+    expect(isUngroupedGroup('custom-group')).toBe(false)
+  })
+})

package/src/saved-views/helpers/defaultGroup.ts

@@ -0,0 +1,70 @@
+import { isObjectLike } from '#lodash'
+import { Nullable } from '../../core/helpers/utilityTypes.js'
+import { base64Decode, base64Encode } from '../../core/utils/base64.js'
+import {
+  isModelResource,
+  isObjectResource,
+  resourceBuilder,
+  ViewerResourcesTarget
+} from '../../viewer/helpers/route.js'
+
+/**
+ * Title used for the default 'Ungrouped Scenes' group in the saved views panel.
+ */
+export const ungroupedScenesGroupTitle = 'Ungrouped'
+
+export type DefaultGroupMetadata = {
+  resourceIds: string[]
+  projectId: string
+  name: 'Default Group'
+}
+
+/**
+ * Converts a resourceId string into a more abstract format used by groups that disregards
+ * specific versions of models and objects.
+ */
+export const formatResourceIdsForGroup = (resources: ViewerResourcesTarget) => {
+  return resourceBuilder()
+    .addResources(resources)
+    .clearVersions()
+    .filter((r) => {
+      // filter out any resources that are not ViewerModelResource or ViewerObjectResource
+      return isModelResource(r) || isObjectResource(r)
+    })
+    .map((r) => r.toString())
+}
+
+export const buildDefaultGroupId = (params: {
+  resourceIds: string[]
+  projectId: string
+}) => {
+  const payload: DefaultGroupMetadata = {
+    resourceIds: formatResourceIdsForGroup(params.resourceIds),
+    projectId: params.projectId,
+    name: 'Default Group'
+  }
+  const str = JSON.stringify(payload)
+  return 'default-' + base64Encode(str)
+}
+
+export const decodeDefaultGroupId = (id: string): Nullable<DefaultGroupMetadata> => {
+  try {
+    if (!isUngroupedGroup(id)) return null
+    const json = base64Decode(id.replace('default-', ''))
+    const obj = JSON.parse(json) as Record<string, unknown>
+    if (
+      !isObjectLike(obj) ||
+      !obj.resourceIds ||
+      !obj.projectId ||
+      obj.name !== 'Default Group'
+    ) {
+      throw new Error('Invalid saved view group ID format')
+    }
+    return obj as Nullable<DefaultGroupMetadata>
+  } catch {
+    // Suppress - not the default group ID
+    return null
+  }
+}
+
+export const isUngroupedGroup = (groupId: string) => groupId.startsWith('default-')

package/src/saved-views/index.ts

@@ -0,0 +1 @@
+export * from './helpers/defaultGroup.js'

package/src/tests/fakes.ts

@@ -4,9 +4,21 @@ import { Comment } from '../authz/domain/comments/types.js'
 import { nanoid } from 'nanoid'
 import { Model } from '../authz/domain/models/types.js'
 import { Version } from '../authz/domain/versions/types.js'
-import { Workspace } from '../authz/domain/workspaces/types.js'
-import { FeatureFlags, parseFeatureFlags } from '../environment/index.js'
+import {
+  Workspace,
+  WorkspaceSsoProvider,
+  WorkspaceSsoSession
+} from '../authz/domain/workspaces/types.js'
+import { parseFeatureFlags } from '../environment/index.js'
 import { mapValues } from 'lodash'
+import { WorkspaceFeatureFlags, WorkspacePlan } from '../workspaces/index.js'
+import { TIME_MS } from '../core/index.js'
+import {
+  SavedView,
+  SavedViewGroup,
+  SavedViewVisibility
+} from '../authz/domain/savedViews/types.js'
+import { FeatureFlags } from '../environment/featureFlags.js'
 
 export const fakeGetFactory =
   <T extends Record<string, unknown>>(defaults: () => T) =>
@@ -28,7 +40,27 @@ export const getProjectFake = fakeGetFactory<Project>(() => ({
 
 export const getWorkspaceFake = fakeGetFactory<Workspace>(() => ({
   id: nanoid(10),
-  slug: nanoid(10)
+  slug: nanoid(10),
+  isExclusive: false
+}))
+
+export const getWorkspacePlanFake = fakeGetFactory<WorkspacePlan>(() => ({
+  name: 'team',
+  status: 'valid',
+  workspaceId: nanoid(10),
+  createdAt: new Date(Date.now() - TIME_MS.day),
+  updatedAt: new Date(Date.now() - TIME_MS.day),
+  featureFlags: WorkspaceFeatureFlags.none
+}))
+
+export const getWorkspaceSsoProviderFake = fakeGetFactory<WorkspaceSsoProvider>(() => ({
+  providerId: nanoid(10)
+}))
+
+export const getWorkspaceSsoSessionFake = fakeGetFactory<WorkspaceSsoSession>(() => ({
+  userId: nanoid(10),
+  providerId: nanoid(10),
+  validUntil: new Date(Date.now() + TIME_MS.day)
 }))
 
 export const getCommentFake = fakeGetFactory<Comment>(() => ({
@@ -50,5 +82,24 @@ export const getVersionFake = fakeGetFactory<Version>(() => ({
   authorId: nanoid(10)
 }))
 
-export const getEnvFake = (overrides?: Partial<FeatureFlags>) =>
+export const getSavedViewFake = fakeGetFactory<SavedView>(() => ({
+  id: nanoid(10),
+  name: nanoid(10),
+  authorId: nanoid(10),
+  projectId: nanoid(10),
+  groupId: null,
+  visibility: SavedViewVisibility.public,
+  resourceIds: [nanoid(10)]
+}))
+
+export const getSavedViewGroupFake = fakeGetFactory<SavedViewGroup>(() => ({
+  id: nanoid(10),
+  name: nanoid(10),
+  projectId: nanoid(10),
+  resourceIds: [nanoid(10)],
+  authorId: nanoid(10)
+}))
+
+// eslint-disable-next-line @typescript-eslint/require-await
+export const getEnvFake = (overrides?: Partial<FeatureFlags>) => async () =>
   parseFeatureFlags(mapValues(overrides || {}, (v) => `${v}` as 'true' | 'false'))