Add missing internal actions and a command to run them

Author: jacobmischka

src/entry.ts

@@ -177,34 +177,50 @@ program
 
 const [cmd, ...args] = program.parse().args
 async function main() {
-  if (cmd === 'start') {
-    const envVars = (await import('./env')).default
-    // start the internal web socket server
-    import('./wss/index')
+  switch (cmd) {
+    case 'start': {
+      const envVars = (await import('./env')).default
+      // start the internal web socket server
+      import('./wss/index')
 
-    const app = express()
+      const app = express()
 
-    const mainAppServer = (await import('./server/index')).default
+      const mainAppServer = (await import('./server/index')).default
 
-    app.use(mainAppServer)
+      app.use(mainAppServer)
 
-    const server = http.createServer(app)
+      const server = http.createServer(app)
 
-    const wss = new WebSocketServer({ server, path: '/websocket' })
-    const { setupWebSocketServer } = await import('./wss/wss')
-    setupWebSocketServer(wss)
+      const wss = new WebSocketServer({ server, path: '/websocket' })
+      const { setupWebSocketServer } = await import('./wss/wss')
+      setupWebSocketServer(wss)
 
-    server.listen(Number(envVars.PORT), () => {
-      logger.info(
-        `📡 Interval Server listening at http://localhost:${envVars.PORT}`
-      )
-    })
-  } else if (cmd === 'db-init') {
-    logger.info('Initializing a database...')
-    initDb({ skipCreate: args.includes('--skip-create') }).catch(() => {
-      logger.error(`Failed to initialize database.`)
-      process.exit(1)
-    })
+      server.listen(Number(envVars.PORT), () => {
+        logger.info(
+          `📡 Interval Server listening at http://localhost:${envVars.PORT}`
+        )
+
+        if (args.includes('--internal-actions')) {
+          import('./interval').catch(err => {
+            logger.error('Failed starting internal actions:', err)
+          })
+        }
+      })
+
+      break
+    }
+    case 'internal': {
+      await import('./interval')
+      break
+    }
+    case 'db-init': {
+      logger.info('Initializing a database...')
+      initDb({ skipCreate: args.includes('--skip-create') }).catch(() => {
+        logger.error('Failed to initialize database.')
+        process.exit(1)
+      })
+      break
+    }
   }
 }
 

src/env.ts

@@ -16,6 +16,9 @@ const schema = z.object({
   WSS_API_SECRET: z.string(),
   AUTH_COOKIE_SECRET: z.string(),
 
+  // for internal interval host
+  INTERVAL_KEY: z.string().optional(),
+
   GIT_COMMIT: z.string().optional(),
   PORT: z.string().optional().default('3000'),
 

src/interval/helpers/findUsers.ts

@@ -0,0 +1,21 @@
+import prisma from '~/server/prisma'
+export default async function findUsers(query: string) {
+  return prisma.user.findMany({
+    where: {
+      OR: [
+        {
+          firstName: {
+            mode: 'insensitive',
+            contains: query,
+          },
+        },
+        {
+          lastName: {
+            mode: 'insensitive',
+            contains: query,
+          },
+        },
+      ],
+    },
+  })
+}

src/interval/helpers/orgRowMenuItems.ts

@@ -0,0 +1,45 @@
+import { MenuItem } from '@interval/sdk/dist/types'
+import { Organization, OrganizationSSO } from '@prisma/client'
+
+export default function orgRowMenuItems(
+  row: Organization & { sso?: Pick<OrganizationSSO, 'id'> | null }
+): MenuItem[] {
+  return [
+    {
+      label: 'Browse app structure',
+      action: 'organizations/app_structure',
+      params: { org: row.slug },
+    },
+    {
+      label: 'Change slug',
+      action: 'organizations/change_slug',
+      params: { org: row.slug },
+    },
+    {
+      label: 'Enable SSO',
+      action: 'organizations/create_org_sso',
+      params: { org: row.slug },
+    },
+    {
+      label: 'Disable SSO',
+      action: 'organizations/disable_org_sso',
+      params: { org: row.slug },
+      disabled: row.sso === null,
+    },
+    {
+      label: 'Toggle feature flag',
+      action: 'organizations/org_feature_flag',
+      params: { org: row.slug },
+    },
+    {
+      label: 'Transfer owner',
+      action: 'organizations/transfer_ownership',
+      params: { org: row.slug },
+    },
+    {
+      label: 'Create transaction history export',
+      action: 'organizations/create_transaction_history_export',
+      params: { org: row.slug },
+    },
+  ]
+}

src/interval/helpers/renderUserResult.ts

@@ -0,0 +1,8 @@
+import { User } from '@prisma/client'
+
+export default function renderUserResult(user: User) {
+  return {
+    label: [user.firstName, user.lastName].join(' '),
+    description: user.email,
+  }
+}

src/interval/helpers/requireOrg.ts

@@ -0,0 +1,21 @@
+import { ctx } from '@interval/sdk'
+import prisma from '~/server/prisma'
+import selectOrganization from './selectOrganization'
+
+export default async function requireOrg(paramName = 'org') {
+  if (paramName in ctx.params) {
+    const org = await prisma.organization.findFirst({
+      where: { slug: String(ctx.params[paramName]) },
+      include: {
+        sso: true,
+        environments: true,
+      },
+    })
+
+    if (!org) throw new Error('Org not found')
+
+    return org
+  }
+
+  return selectOrganization()
+}

src/interval/helpers/requireParam.ts

@@ -0,0 +1,9 @@
+import { ctx } from '@interval/sdk'
+
+export default function requireParam(key: string) {
+  if (ctx.params[key] === undefined) {
+    throw new Error(`Missing required param: ${key}`)
+  }
+
+  return String(ctx.params[key])
+}

src/interval/helpers/searchForOrganization.ts

@@ -0,0 +1,40 @@
+import { io } from '@interval/sdk'
+import { Prisma } from '@prisma/client'
+
+import prisma from '~/server/prisma'
+
+export default async function searchForOrganization() {
+  return io.search<Prisma.OrganizationGetPayload<{ include: { owner: true } }>>(
+    'Select organization',
+    {
+      async onSearch(query) {
+        return prisma.organization.findMany({
+          where: {
+            OR: [
+              {
+                name: {
+                  search: query,
+                  mode: 'insensitive',
+                },
+              },
+              {
+                name: {
+                  contains: query,
+                  mode: 'insensitive',
+                },
+              },
+            ],
+          },
+          include: {
+            owner: true,
+          },
+        })
+      },
+      renderResult: org => ({
+        value: org.id,
+        label: org.name,
+        description: `Owner: ${org.owner.firstName} ${org.owner.lastName} (${org.owner.email}), Slug: ${org.slug}`,
+      }),
+    }
+  )
+}

src/interval/helpers/selectOrganization.ts

@@ -0,0 +1,22 @@
+import prisma from '~/server/prisma'
+import searchForOrganization from './searchForOrganization'
+
+export default async function selectOrganization() {
+  const selected = await searchForOrganization()
+
+  const org = await prisma.organization.findUnique({
+    where: {
+      id: selected.id,
+    },
+    include: {
+      sso: true,
+      environments: true,
+    },
+  })
+
+  if (!org) {
+    throw new Error("Organization doesn't exist?")
+  }
+
+  return org
+}

src/interval/helpers/selectUser.ts

@@ -0,0 +1,10 @@
+import { io } from '@interval/sdk'
+import findUsers from './findUsers'
+import renderUserResult from './renderUserResult'
+
+export default function selectUser() {
+  return io.search('Select a user', {
+    onSearch: async q => await findUsers(q),
+    renderResult: renderUserResult,
+  })
+}