@synchronized-console/shared 2.25.7 → 2.31.14

package/src/authz/policies/workspace/{canUpdateEmbedOptions.spec.ts → canUseWorkspacePlanFeature.spec.ts}

@@ -2,25 +2,29 @@ import cryptoRandomString from 'crypto-random-string'
 import { Roles } from '../../../core/constants.js'
 import { parseFeatureFlags } from '../../../environment/index.js'
 import { Workspace } from '../../domain/workspaces/types.js'
-import { canUpdateEmbedOptionsPolicy } from './canUpdateEmbedOptions.js'
-import { WorkspacePlan } from '../../../workspaces/index.js'
+import { canUseWorkspacePlanFeature } from './canUseWorkspacePlanFeature.js'
+import {
+  WorkspaceFeatureFlags,
+  WorkspacePlanFeatures
+} from '../../../workspaces/index.js'
 import { describe, expect, it } from 'vitest'
 import {
   ServerNoAccessError,
   ServerNoSessionError,
   ServerNotEnoughPermissionsError,
   WorkspaceNoAccessError,
-  WorkspaceNoFeatureAccessError,
+  WorkspacePlanNoFeatureAccessError,
   WorkspaceNotEnoughPermissionsError,
   WorkspaceReadOnlyError
 } from '../../domain/authErrors.js'
+import { getWorkspacePlanFake } from '../../../tests/fakes.js'
 
-const buildCanUpdateEmbedOptionsPolicy = (
-  overrides?: Partial<Parameters<typeof canUpdateEmbedOptionsPolicy>[0]>
+const buildSUT = (
+  overrides?: Partial<Parameters<typeof canUseWorkspacePlanFeature>[0]>
 ) => {
   const workspaceId = cryptoRandomString({ length: 9 })
 
-  return canUpdateEmbedOptionsPolicy({
+  return canUseWorkspacePlanFeature({
     getEnv: async () =>
       parseFeatureFlags({
         FF_WORKSPACES_MODULE_ENABLED: 'true'
@@ -35,29 +39,22 @@ const buildCanUpdateEmbedOptionsPolicy = (
     getWorkspaceRole: async () => Roles.Workspace.Admin,
     getWorkspaceSsoProvider: async () => null,
     getWorkspaceSsoSession: async () => null,
-    getWorkspacePlan: async () => {
-      return {
-        workspaceId,
-        name: 'unlimited',
-        status: 'valid',
-        createdAt: new Date(),
-        updatedAt: new Date()
-      } as WorkspacePlan
-    },
+    getWorkspacePlan: getWorkspacePlanFake({ workspaceId, name: 'unlimited' }),
     ...overrides
   })
 }
 
 const getPolicyArgs = () => ({
   userId: cryptoRandomString({ length: 9 }),
-  workspaceId: cryptoRandomString({ length: 9 })
+  workspaceId: cryptoRandomString({ length: 9 }),
+  feature: WorkspacePlanFeatures.HideSynchronizedBranding
 })
 
-describe('canUpdateEmbedOptions', () => {
+describe('canUseFeature', () => {
   it('returns error if user is not logged in', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy()
+    const canUseFeature = buildSUT()
 
-    const result = await canUpdateEmbedOptions({
+    const result = await canUseFeature({
       ...getPolicyArgs(),
       userId: undefined
     })
@@ -68,11 +65,11 @@ describe('canUpdateEmbedOptions', () => {
   })
 
   it('returns error if user is not found', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy({
+    const canUseFeature = buildSUT({
       getServerRole: async () => null
     })
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature(getPolicyArgs())
 
     expect(result).toBeAuthErrorResult({
       code: ServerNoAccessError.code
@@ -80,11 +77,11 @@ describe('canUpdateEmbedOptions', () => {
   })
 
   it('returns error if user is a server guest', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy({
+    const canUseFeature = buildSUT({
       getServerRole: async () => Roles.Server.Guest
     })
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature(getPolicyArgs())
 
     expect(result).toBeAuthErrorResult({
       code: ServerNotEnoughPermissionsError.code
@@ -92,11 +89,11 @@ describe('canUpdateEmbedOptions', () => {
   })
 
   it('returns error if workspace does not exist', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy({
+    const canUseFeature = buildSUT({
       getWorkspace: async () => null
     })
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature(getPolicyArgs())
 
     expect(result).toBeAuthErrorResult({
       code: WorkspaceNoAccessError.code
@@ -104,11 +101,11 @@ describe('canUpdateEmbedOptions', () => {
   })
 
   it('returns error if user is not workspace admin', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy({
+    const canUseFeature = buildSUT({
       getWorkspaceRole: async () => Roles.Workspace.Member
     })
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature(getPolicyArgs())
 
     expect(result).toBeAuthErrorResult({
       code: WorkspaceNotEnoughPermissionsError.code
@@ -116,45 +113,50 @@ describe('canUpdateEmbedOptions', () => {
   })
 
   it('returns error if workspace is read only', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy({
+    const canUseFeature = buildSUT({
       getWorkspacePlan: async () => ({
         workspaceId: cryptoRandomString({ length: 9 }),
         name: 'proUnlimited',
         status: 'canceled',
         createdAt: new Date(),
-        updatedAt: new Date()
+        updatedAt: new Date(),
+        featureFlags: WorkspaceFeatureFlags.none
       })
     })
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature(getPolicyArgs())
 
     expect(result).toBeAuthErrorResult({
       code: WorkspaceReadOnlyError.code
     })
   })
 
-  it('returns error if workspace has invalid plan', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy({
+  it('returns error if workspace plan does not have access to the feature', async () => {
+    const canUseFeature = buildSUT({
       getWorkspacePlan: async () => ({
         workspaceId: cryptoRandomString({ length: 9 }),
         name: 'free',
         status: 'valid',
         createdAt: new Date(),
-        updatedAt: new Date()
+        updatedAt: new Date(),
+        featureFlags: WorkspaceFeatureFlags.none
       })
     })
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature({
+      ...getPolicyArgs(),
+      feature: WorkspacePlanFeatures.CustomDataRegion
+    })
 
     expect(result).toBeAuthErrorResult({
-      code: WorkspaceNoFeatureAccessError.code
+      code: WorkspacePlanNoFeatureAccessError.code
     })
   })
 
-  it('returns ok if workspace has valid plan', async () => {
-    const canUpdateEmbedOptions = buildCanUpdateEmbedOptionsPolicy()
+  it('returns ok if workspace plan has access to the feature', async () => {
+    const canUseFeature = buildSUT()
 
-    const result = await canUpdateEmbedOptions(getPolicyArgs())
+    const result = await canUseFeature(getPolicyArgs())
 
     expect(result).toBeAuthOKResult()
   })

package/src/authz/policies/workspace/canUseWorkspacePlanFeature.ts

@@ -0,0 +1,69 @@
+import { err, ok } from 'true-myth/result'
+import {
+  ServerNoAccessError,
+  ServerNoSessionError,
+  ServerNotEnoughPermissionsError,
+  WorkspaceNoAccessError,
+  WorkspacePlanNoFeatureAccessError,
+  WorkspaceNotEnoughPermissionsError,
+  WorkspaceReadOnlyError,
+  WorkspacesNotEnabledError,
+  WorkspaceSsoSessionNoAccessError
+} from '../../domain/authErrors.js'
+import { MaybeUserContext, WorkspaceContext } from '../../domain/context.js'
+import { AuthCheckContextLoaderKeys } from '../../domain/loaders.js'
+import { AuthPolicy } from '../../domain/policies.js'
+import {
+  ensureCanUseWorkspacePlanFeatureFragment,
+  ensureUserIsWorkspaceAdminFragment
+} from '../../fragments/workspaces.js'
+import { WorkspacePlanFeatures } from '../../../workspaces/index.js'
+
+type PolicyLoaderKeys =
+  | typeof AuthCheckContextLoaderKeys.getEnv
+  | typeof AuthCheckContextLoaderKeys.getServerRole
+  | typeof AuthCheckContextLoaderKeys.getWorkspace
+  | typeof AuthCheckContextLoaderKeys.getWorkspaceRole
+  | typeof AuthCheckContextLoaderKeys.getWorkspaceSsoProvider
+  | typeof AuthCheckContextLoaderKeys.getWorkspaceSsoSession
+  | typeof AuthCheckContextLoaderKeys.getWorkspacePlan
+
+type PolicyArgs = MaybeUserContext &
+  WorkspaceContext & { feature: WorkspacePlanFeatures }
+
+type PolicyErrors =
+  | InstanceType<typeof WorkspaceNoAccessError>
+  | InstanceType<typeof WorkspaceSsoSessionNoAccessError>
+  | InstanceType<typeof WorkspaceReadOnlyError>
+  | InstanceType<typeof WorkspacesNotEnabledError>
+  | InstanceType<typeof ServerNoSessionError>
+  | InstanceType<typeof ServerNoAccessError>
+  | InstanceType<typeof ServerNotEnoughPermissionsError>
+  | InstanceType<typeof WorkspaceNotEnoughPermissionsError>
+  | InstanceType<typeof WorkspacePlanNoFeatureAccessError>
+
+/**
+ * TODO: Refactor. Just use the fragment if you want to check if a workspace has access to a feature,
+ * and create more specific policies for the actual use cases, cause policies shouldn't be reusable
+ * building blocks like this.
+ */
+export const canUseWorkspacePlanFeature: AuthPolicy<
+  PolicyLoaderKeys,
+  PolicyArgs,
+  PolicyErrors
+> =
+  (loaders) =>
+  async ({ userId, workspaceId, feature }) => {
+    const isWorkspaceAdmin = await ensureUserIsWorkspaceAdminFragment(loaders)({
+      userId,
+      workspaceId
+    })
+    if (isWorkspaceAdmin.isErr) return err(isWorkspaceAdmin.error)
+
+    const canUseFeature = await ensureCanUseWorkspacePlanFeatureFragment(loaders)({
+      workspaceId,
+      feature
+    })
+    if (canUseFeature.isErr) return err(canUseFeature.error)
+    return ok()
+  }

package/src/automate/helpers/types.ts

@@ -81,13 +81,27 @@ export const resultSchemaV2 = z.object({
   })
 })
 
+export type ResultSchemaV2 = z.infer<typeof resultSchemaV2>
+
+const versionResultV3 = z.record(z.string(), z.unknown())
+
+export const resultSchemaV3 = z.object({
+  version: z.literal(3),
+  values: z.object({
+    versionResult: versionResultV3.optional(),
+    objectResults: objectResultV2.array().optional(),
+    blobIds: z.string().array().optional()
+  })
+})
+
+export type ResultSchemaV3 = z.infer<typeof resultSchemaV3>
+
 export const resultSchema = z.discriminatedUnion('version', [
   resultSchemaV1,
-  resultSchemaV2
+  resultSchemaV2,
+  resultSchemaV3
 ])
 
-export type ResultSchemaV2 = z.infer<typeof resultSchemaV2>
-
 export type ResultsSchema = z.infer<typeof resultSchema>
 
 type UnformattedTriggerDefinitionSchema = PartialDeep<TriggerDefinitionsSchema>

package/src/blobs/index.ts

@@ -0,0 +1,121 @@
+// This is the exhaustive list of all the file extensions that the rhino processor can convert
+// Items that we don't want to expose are intentionally commented out in place
+// Either because they don't deliver value, or don't convert well.
+// The items left un-commented have been validated they work well with Synchronized
+export const rhinoImporterSupportedFileExtensions = new Set([
+  '3dm',
+  // '3dmbak',
+  // 'rws',
+  '3mf',
+  '3ds',
+  'amf',
+  // 'ai',
+  'dwg',
+  'dxf',
+  'x',
+  'e57',
+  // 'dst',
+  // 'exp',
+  // 'dst',
+  // 'exp',
+  // 'off',
+  // 'gf',
+  // 'gft',
+  // 'gltf',
+  // 'glb',
+  // 'gts',
+  'igs',
+  'iges',
+  // 'lwo',
+  'dgn',
+  'fbx',
+  // 'scn',
+  'obj',
+  // 'pdf',
+  'ply',
+  // 'asc',
+  // 'csv',
+  // 'xyz',
+  // 'pts',
+  // 'cgo_ascii',
+  // 'cgo_asci',
+  // 'txt',
+  // 'raw',
+  // 'm',
+  // 'pts',
+  // 'svg',
+  'skp',
+  // 'slc',
+  'sldprt',
+  // 'sldasm',
+  'stp',
+  'step',
+  'stl'
+  // 'vda',
+  // 'wrl',
+  // 'vrml',
+  // 'iv',
+  // 'gdf'
+])
+
+// For comments attachments, could be moved back to frontend-2
+export const acceptedFileExtensions = [
+  'pdf',
+  'zip',
+  '7z',
+  'pptx',
+  'ifc',
+  'dwg',
+  'dxf',
+  '3dm',
+  'ghx',
+  'gh',
+  'rvt',
+  'pla',
+  'pln',
+  'obj',
+  'blend',
+  '3ds',
+  'max',
+  'mtl',
+  'stl',
+  'md',
+  'txt',
+  'csv',
+  'xlsx',
+  'xls',
+  'doc',
+  'docx',
+  'svg',
+  'eps',
+  'gwb',
+  'skp',
+  'pbix'
+]
+
+export const BlobUploadStatus = <const>{
+  Pending: 0,
+  Completed: 1,
+  Error: 2
+}
+
+export type BlobUploadStatus = (typeof BlobUploadStatus)[keyof typeof BlobUploadStatus]
+export const FileUploadConvertedStatus = <const>{
+  Queued: 0,
+  Converting: 1,
+  Completed: 2,
+  Error: 3
+}
+
+export type FileUploadConvertedStatus =
+  (typeof FileUploadConvertedStatus)[keyof typeof FileUploadConvertedStatus]
+
+export const fileUploadConvertedStatusLabels: Record<
+  FileUploadConvertedStatus,
+  string
+> = {
+  [FileUploadConvertedStatus.Queued]: 'Queued',
+  [FileUploadConvertedStatus.Converting]: 'Converting',
+  [FileUploadConvertedStatus.Completed]: 'Completed',
+  [FileUploadConvertedStatus.Error]: 'Error'
+}

package/src/core/constants.ts

@@ -112,6 +112,7 @@ export const Scopes = Object.freeze(<const>{
   },
   Profile: {
     Read: 'profile:read',
+    Write: 'profile:write',
     Email: 'profile:email',
     Delete: 'profile:delete'
   },
@@ -187,6 +188,7 @@ export const isScope = (scope: unknown): scope is ServerScope =>
   !!(scope && (AllScopes as unknown[]).includes(scope))
 
 export const SourceAppNames = [
+  'Advance Steel',
   'Dynamo',
   'Revit',
   'AutoCAD',
@@ -194,6 +196,7 @@ export const SourceAppNames = [
   'Blender',
   'Rhino',
   'Grasshopper',
+  'GSA',
   'Excel',
   'Unity',
   'Unreal',
@@ -215,7 +218,10 @@ export const SourceAppNames = [
   'OpenBuildings',
   'MicroStation',
   'Navisworks',
-  'Synchronized Automate'
+  'Synchronized Automate',
+  'TopSolid',
+  'File Import',
+  'Acc integration'
 ] as const
 
 export type SourceAppName = (typeof SourceAppNames)[number]
@@ -223,6 +229,7 @@ export type SourceAppName = (typeof SourceAppNames)[number]
 export type SourceAppDefinition = {
   /**
    * String to look for in input app names to match them to a specific source app
+   * this is an eqiuvalent of the connector slug
    */
   searchKey: string
 
@@ -243,10 +250,22 @@ export type SourceAppDefinition = {
 }
 
 export const SourceApps: SourceAppDefinition[] = [
+  // ordering of the list is important.
+  // this will match all acc file importers
+  { searchKey: '-acc', name: 'Acc integration', short: 'ACC', bgColor: '#3091e7' },
+  {
+    // this will match all rhino based file importers
+    searchKey: '-rhino-importer',
+    name: 'File Import',
+    short: '',
+    bgColor: '#3091e7'
+  },
+  { searchKey: 'advancesteel', name: 'Advance Steel', short: 'AS', bgColor: '#a438b6' },
+  // deliberately keeping dynamo in front of revit, so it preceeds it when resolving from the host app name
   { searchKey: 'dynamo', name: 'Dynamo', short: 'DYN', bgColor: '#a438b6' },
   { searchKey: 'revit', name: 'Revit', short: 'RVT', bgColor: '#3091e7' },
   { searchKey: 'autocad', name: 'AutoCAD', short: 'ACAD', bgColor: '#f0605e' },
-  { searchKey: 'civil', name: 'Civil3D', short: 'C3D', bgColor: '#14c1d7' },
+  { searchKey: 'civil3d', name: 'Civil3D', short: 'C3D', bgColor: '#14c1d7' },
   { searchKey: 'blender', name: 'Blender', short: 'BLEND', bgColor: '#fb9514' },
   { searchKey: 'rhino', name: 'Rhino', short: 'RH', bgColor: '#141414' },
   { searchKey: 'grasshopper', name: 'Grasshopper', short: 'GH', bgColor: '#48974b' },
@@ -254,17 +273,19 @@ export const SourceApps: SourceAppDefinition[] = [
   { searchKey: 'unity', name: 'Unity', short: 'UNITY', bgColor: '#149e91' },
   { searchKey: 'unreal', name: 'Unreal', short: 'UE', bgColor: '#846256' },
   { searchKey: 'python', name: 'Python', short: 'PY', bgColor: '#fddb45' },
-  { searchKey: '.net', name: '.NET', short: '.NET', bgColor: '#8531a9' },
+  { searchKey: 'net', name: '.NET', short: '.NET', bgColor: '#8531a9' },
   { searchKey: 'ifc', name: 'IFC', short: 'IFC', bgColor: '#bd2e2e' },
   { searchKey: 'qgis', name: 'QGIS', short: 'QGIS', bgColor: '#70e029' },
+  { searchKey: 'gsa', name: 'GSA', short: 'GSA', bgColor: '#70e029' },
   { searchKey: 'arcgis', name: 'ArcGIS', short: 'AGIS', bgColor: '#3a6eff' },
   { searchKey: 'etabs', name: 'ETABS', short: 'EDB', bgColor: '#6d6d6d' },
   { searchKey: 'powerbi', name: 'PowerBI', short: 'PBI', bgColor: '#ffff96' },
   { searchKey: 'sketchup', name: 'SketchUp', short: 'SKP', bgColor: '#8cb7ff' },
-  { searchKey: 'sap', name: 'SAP2000', short: 'SAP', bgColor: '#6d6d6d' },
+  { searchKey: 'sap2000', name: 'SAP2000', short: 'SAP', bgColor: '#6d6d6d' },
   { searchKey: 'csibridge', name: 'CSiBridge', short: 'CSIB', bgColor: '#6d6d6d' },
   { searchKey: 'safe', name: 'SAFE', short: 'SAFE', bgColor: '#6d6d6d' },
   { searchKey: 'archicad', name: 'Archicad', short: 'ARCHI', bgColor: '#3091e7' },
+  { searchKey: 'topsolid', name: 'TopSolid', short: 'TOPS', bgColor: '#3091e7' },
   {
     searchKey: 'teklastructures',
     name: 'Tekla Structures',

package/src/core/helpers/encoding.ts

@@ -0,0 +1,12 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const safeParse = <Result = any>(
+  json: string,
+  guard?: (data: unknown) => data is Result
+): Result | null => {
+  try {
+    const parsed = JSON.parse(json) as Result
+    return guard ? (guard(parsed) ? parsed : null) : parsed
+  } catch {
+    return null
+  }
+}