t44 0.4.0-rc.3

package/caps/providers/semver.org/ProjectPublishing.ts

@@ -0,0 +1,286 @@
+
+import { join } from 'path'
+import { readFile, writeFile } from 'fs/promises'
+import glob from 'fast-glob'
+import chalk from 'chalk'
+
+function detectIndent(content: string): number {
+    const match = content.match(/^\{\s*\n([ \t]+)/)
+    if (match) {
+        return match[1].length
+    }
+    return 2
+}
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/WorkspacePublishingConfig': {
+                as: '$WorkspaceRepositories'
+            },
+            '#t44/structs/WorkspaceMappingsConfig': {
+                as: '$WorkspaceMappings'
+            },
+            '#': {
+                rename: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { dirs, repos }: { dirs: Iterable<string>, repos?: Record<string, any> }) {
+                        const mappingsConfig = await this.$WorkspaceMappings.config
+                        const publishingMappings = mappingsConfig?.mappings?.['t44/caps/providers/ProjectPublishing']
+                        if (publishingMappings?.npm) {
+                            const npmRenames: Record<string, string> = publishingMappings.npm
+                            const renameEntries = Object.entries(npmRenames)
+                                .sort((a, b) => b[0].length - a[0].length)
+
+                            if (renameEntries.length > 0) {
+                                console.log('[t44] Applying package name renames ...\n')
+
+                                for (const dir of dirs) {
+                                    const files = await glob('**/*', {
+                                        cwd: dir,
+                                        absolute: true,
+                                        onlyFiles: true,
+                                        dot: true
+                                    })
+
+                                    for (const file of files) {
+                                        try {
+                                            const buffer = await readFile(file)
+
+                                            // Detect binary files by checking for null bytes (the standard
+                                            // heuristic used by git, diff, file(1), etc.)
+                                            if (buffer.includes(0x00)) continue
+
+                                            let content = buffer.toString('utf-8')
+                                            let modified = false
+
+                                            for (const [workspaceName, publicName] of renameEntries) {
+                                                const regex = new RegExp(workspaceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')
+                                                const replaced = content.replace(regex, publicName)
+                                                if (replaced !== content) {
+                                                    content = replaced
+                                                    modified = true
+                                                }
+                                            }
+
+                                            if (modified) {
+                                                await writeFile(file, content, 'utf-8')
+                                            }
+                                        } catch (e) {
+                                            // Skip files that can't be read
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        // Resolve workspace:* dependencies
+                        if (repos) {
+                            const repositoriesConfig = await this.$WorkspaceRepositories.config
+                            const mappingsConfig = await this.$WorkspaceMappings.config
+                            const npmRenames: Record<string, string> = mappingsConfig?.mappings?.['t44/caps/providers/ProjectPublishing']?.npm || {}
+                            const { publicNpmPackageNames, workspaceNpmPackageNames, workspacePackageSourceDirs } = await buildWorkspacePackageMaps(repositoriesConfig, npmRenames)
+
+                            console.log('[t44] Resolving workspace dependencies ...\n')
+                            for (const [repoName, repoSourceDir] of Object.entries(repos)) {
+                                const packageJsonPath = join(repoSourceDir as string, 'package.json')
+
+                                const packageJsonContent = await readFile(packageJsonPath, 'utf-8')
+                                const indent = detectIndent(packageJsonContent)
+                                const packageJson = JSON.parse(packageJsonContent)
+
+                                await updateWorkspaceDependencies(packageJson, workspaceNpmPackageNames, workspacePackageSourceDirs, publicNpmPackageNames)
+
+                                const updatedContent = JSON.stringify(packageJson, null, indent) + '\n'
+                                if (updatedContent !== packageJsonContent) {
+                                    await writeFile(packageJsonPath, updatedContent, 'utf-8')
+                                    console.log(chalk.green(`  ✓ Updated workspace dependencies in ${packageJsonPath}\n`))
+                                }
+                            }
+                        }
+                    }
+                },
+                bump: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config, options }: { config: any, options?: { rc?: boolean, release?: boolean } }) {
+                        const { rc, release } = options || {}
+
+                        const projectSourceDir = join(config.sourceDir)
+                        const packageJsonPath = join(projectSourceDir, 'package.json')
+
+                        const packageJsonContent = await readFile(packageJsonPath, 'utf-8')
+                        const packageJson = JSON.parse(packageJsonContent)
+                        const currentVersion = packageJson.version
+
+                        let newVersion: string
+
+                        if (release) {
+                            const rcMatch = currentVersion.match(/^(.+)-rc\.\d+$/)
+                            if (rcMatch) {
+                                newVersion = rcMatch[1]
+                                console.log(chalk.cyan(`  Removing RC suffix: ${currentVersion} → ${newVersion}`))
+                            } else {
+                                console.log(chalk.yellow(`  Version ${currentVersion} has no RC suffix, skipping bump`))
+                                return
+                            }
+                        } else if (rc) {
+                            const rcMatch = currentVersion.match(/^(.+)-rc\.(\d+)$/)
+                            if (rcMatch) {
+                                const baseVersion = rcMatch[1]
+                                const rcNumber = parseInt(rcMatch[2], 10)
+                                newVersion = `${baseVersion}-rc.${rcNumber + 1}`
+                                console.log(chalk.cyan(`  Incrementing RC version: ${currentVersion} → ${newVersion}`))
+                            } else {
+                                const versionParts = currentVersion.split('.')
+                                if (versionParts.length !== 3) {
+                                    throw new Error(`Invalid version format: ${currentVersion}`)
+                                }
+                                const [major, minor, patch] = versionParts
+                                const newMinor = parseInt(minor, 10) + 1
+                                newVersion = `${major}.${newMinor}.0-rc.1`
+                                console.log(chalk.cyan(`  Bumping minor version and adding RC: ${currentVersion} → ${newVersion}`))
+                            }
+                        } else {
+                            console.log(chalk.yellow(`  No version bump requested`))
+                            return
+                        }
+
+                        packageJson.version = newVersion
+                        const indent = detectIndent(packageJsonContent)
+                        const updatedContent = JSON.stringify(packageJson, null, indent) + '\n'
+                        await writeFile(packageJsonPath, updatedContent, 'utf-8')
+
+                        console.log(chalk.green(`  ✓ Updated ${packageJsonPath} to version ${newVersion}\n`))
+
+                        return { newVersion }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/semver.org/ProjectPublishing'
+
+
+async function buildWorkspacePackageMaps(repositoriesConfig: any, npmRenames: Record<string, string>) {
+    const publicNpmPackageNames: Record<string, string> = {}
+    const workspaceNpmPackageNames: Record<string, string> = {}
+    const workspacePackageSourceDirs: Record<string, string> = {}
+
+    // Build reverse rename map: publicName → workspaceName
+    const reverseRenames: Record<string, string> = {}
+    for (const [workspaceName, publicName] of Object.entries(npmRenames)) {
+        reverseRenames[publicName] = workspaceName
+    }
+
+    if (repositoriesConfig?.repositories) {
+        for (const [repoKey, repoConfig] of Object.entries(repositoriesConfig.repositories as any)) {
+            const sourceDir = (repoConfig as any).sourceDir
+            if (!sourceDir) continue
+
+            const packageJsonPath = join(sourceDir, 'package.json')
+
+            try {
+                const packageJsonContent = await readFile(packageJsonPath, 'utf-8')
+                const packageJson = JSON.parse(packageJsonContent)
+                const workspacePackageName = packageJson.name
+
+                // Index source dir by the original workspace package name
+                workspacePackageSourceDirs[workspacePackageName] = sourceDir
+
+                // Also index by the renamed (public) name if a rename mapping exists
+                const renamedName = npmRenames[workspacePackageName]
+                if (renamedName) {
+                    workspacePackageSourceDirs[renamedName] = sourceDir
+                    workspaceNpmPackageNames[renamedName] = workspacePackageName
+                }
+            } catch (error) {
+                // Skip repos without a readable package.json
+            }
+
+            const providers = (repoConfig as any).providers || ((repoConfig as any).provider ? [(repoConfig as any).provider] : [])
+
+            for (const provider of providers) {
+                if (provider.capsule === 't44/caps/providers/npmjs.com/ProjectPublishing') {
+                    try {
+                        const packageJsonContent = await readFile(packageJsonPath, 'utf-8')
+                        const packageJson = JSON.parse(packageJsonContent)
+                        const workspacePackageName = packageJson.name
+                        const publicPackageName = provider.config.PackageSettings.name
+
+                        publicNpmPackageNames[workspacePackageName] = publicPackageName
+                        workspaceNpmPackageNames[publicPackageName] = workspacePackageName
+                        // Also index source dir by the public package name
+                        workspacePackageSourceDirs[publicPackageName] = sourceDir
+                    } catch (error) {
+                        throw new Error(`Could not read package.json from ${packageJsonPath}: ${error}`)
+                    }
+                }
+            }
+        }
+    }
+
+    return { publicNpmPackageNames, workspaceNpmPackageNames, workspacePackageSourceDirs }
+}
+
+async function updateWorkspaceDependencies(
+    packageJson: any,
+    workspaceNpmPackageNames: Record<string, string>,
+    workspacePackageSourceDirs: Record<string, string>,
+    publicNpmPackageNames: Record<string, string>
+) {
+    const dependencyFields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']
+    const currentPackageName = packageJson.name
+
+    for (const depField of dependencyFields) {
+        if (packageJson[depField]) {
+            const updatedDeps: Record<string, string> = {}
+
+            for (const [depName, depVersion] of Object.entries(packageJson[depField])) {
+                // Skip self-referencing dependencies
+                if (depName === currentPackageName) {
+                    continue
+                }
+
+                if (typeof depVersion === 'string' && depVersion.startsWith('workspace:')) {
+                    try {
+                        const workspaceDepName = workspaceNpmPackageNames[depName] || depName
+                        const depSourceDir = workspacePackageSourceDirs[workspaceDepName]
+
+                        if (!depSourceDir) {
+                            throw new Error(`Could not find source directory for workspace dependency ${depName} (${workspaceDepName})`)
+                        }
+
+                        const depPackageJsonPath = join(depSourceDir, 'package.json')
+                        const depPackageJsonContent = await readFile(depPackageJsonPath, 'utf-8')
+                        const depPackageJson = JSON.parse(depPackageJsonContent)
+
+                        // Replace workspace package name with public package name
+                        const publicDepName = publicNpmPackageNames[workspaceDepName] || depName
+                        updatedDeps[publicDepName] = `^${depPackageJson.version}`
+                    } catch (error) {
+                        throw new Error(`Could not resolve workspace dependency ${depName}: ${error}`)
+                    }
+                } else {
+                    // Keep non-workspace dependencies as-is
+                    updatedDeps[depName] = depVersion as string
+                }
+            }
+
+            packageJson[depField] = updatedDeps
+        }
+    }
+}

package/caps/providers/vercel.com/ProjectDeployment.ts

@@ -0,0 +1,326 @@
+
+import { join } from 'path'
+import { $ } from 'bun'
+import { mkdir, writeFile } from 'fs/promises'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    // High level API that deals with everything concerning deployment of projects.
+    // NOTE: The API signatures do NOT match the vercel SDK and this is on purpose.
+    //       The goal is to move towards a standard 'deployment' API that can be used across providers.
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/providers/vercel.com/ProjectDeploymentFact': {
+                as: '$ProjectDeploymentFact'
+            },
+            '#t44/structs/ProjectDeploymentFact': {
+                as: '$StatusFact'
+            },
+            '#': {
+                project: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './project'
+                },
+                deploy: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { projectionDir, alias, config }: { projectionDir: string, alias: string, config: any }) {
+
+                        const projectName = config.provider.config.ProjectSettings.name
+                        const projectSettings = {
+                            ...config.provider.config.ProjectSettings || {},
+                            name: undefined
+                        }
+
+                        console.log(`Ensure project '${projectName}' is created on Vercel ...`)
+
+                        const details = await this.project.ensureCreated({
+                            name: projectName,
+                            settings: projectSettings
+                        })
+
+                        console.log(`Project ID: ${details.id}`)
+
+                        // Set environment variables if configured
+                        if (config.provider.config.ENV) {
+                            console.log(`Managing environment variables ...`)
+
+                            // Get existing environment variables
+                            const team = await this.project.vercel.getDefaultTeam()
+                            const existingVars = await (await this.project.vercel.vercel).projects.filterProjectEnvs({
+                                idOrName: details.id,
+                                slug: team
+                            })
+
+                            const existingVarMap = new Map<string, string>(
+                                existingVars.envs?.map((env: any) => [env.key as string, env.id as string]) || []
+                            )
+
+                            const configuredKeys = new Set(Object.keys(config.provider.config.ENV))
+
+                            // Delete variables that are no longer defined
+                            for (const [key, envId] of existingVarMap.entries()) {
+                                if (!configuredKeys.has(key)) {
+                                    await (await this.project.vercel.vercel).projects.removeProjectEnv({
+                                        idOrName: details.id,
+                                        slug: team,
+                                        id: envId
+                                    })
+                                    console.log(`Deleted environment variable: ${key}`)
+                                }
+                            }
+
+                            // Create or update environment variables
+                            for (const [key, value] of Object.entries(config.provider.config.ENV)) {
+
+                                // If value is a function (jit expression), execute it
+                                const resolvedValue = typeof value === 'function'
+                                    ? await value()
+                                    : value as string
+
+                                if (!existingVarMap.has(key)) {
+                                    // Create new variable
+                                    await (await this.project.vercel.vercel).projects.createProjectEnv({
+                                        idOrName: details.id,
+                                        slug: team,
+                                        requestBody: {
+                                            key,
+                                            value: resolvedValue,
+                                            type: 'encrypted',
+                                            target: ['production', 'preview', 'development']
+                                        }
+                                    })
+                                    console.log(`Created environment variable: ${key}`, resolvedValue)
+                                } else {
+                                    // Update existing variable
+                                    const envId = existingVarMap.get(key)!
+                                    await (await this.project.vercel.vercel).projects.editProjectEnv({
+                                        idOrName: details.id,
+                                        slug: team,
+                                        id: envId,
+                                        requestBody: {
+                                            value: resolvedValue,
+                                            type: 'encrypted',
+                                            target: ['production', 'preview', 'development']
+                                        }
+                                    })
+                                    console.log(`Updated environment variable: ${key}`)
+                                }
+                            }
+
+                            console.log(`Environment variables configured.`)
+                        }
+
+                        const projectSourceDir = join(config.sourceDir)
+                        const projectProjectionDir = join(projectionDir, 'projects', projectName)
+
+                        await $`rm -Rf "${projectProjectionDir}" && mkdir -p "${projectProjectionDir}" && rsync -a "${projectSourceDir}/" "${projectProjectionDir}/"`
+
+                        const vercelDir = join(projectProjectionDir, '.vercel')
+                        await mkdir(vercelDir, { recursive: true })
+
+                        const defaultTeam = await this.project.vercel.getDefaultTeam()
+                        const projectJson = {
+                            projectId: details.id,
+                            orgId: await this.project.vercel.orgIdForName({
+                                name: defaultTeam
+                            }),
+                            projectName
+                        }
+                        await writeFile(
+                            join(vercelDir, 'project.json'),
+                            JSON.stringify(projectJson, null, 4)
+                        )
+
+                        const vercelJsonConfig = config.provider.config['/vercel.json'] || {}
+                        const vercelJson = {
+                            framework: vercelJsonConfig.framework,
+                            installCommand: vercelJsonConfig.installCommand || 'bun install',
+                            buildCommand: vercelJsonConfig.buildCommand || 'bun run build',
+                            outputDirectory: vercelJsonConfig.outputDirectory
+                        }
+                        await writeFile(
+                            join(projectProjectionDir, 'vercel.json'),
+                            JSON.stringify(vercelJson, null, 4)
+                        )
+
+                        console.log(`Deploying to vercel ...`)
+
+                        await $`vercel link --yes --project ${projectJson.projectName}`.cwd(projectProjectionDir)
+                        await $`vercel deploy --force --target=preview`.cwd(projectProjectionDir)
+                        // TODO: Add a workspace ID: '--meta WORKSPACE_ID=<id>'
+
+                        console.log(`Deployment to vercel done.`)
+
+                        // Fetch and store project details (automatically saved via $ProjectDeploymentFact)
+                        await this.project.get({
+                            name: details.name
+                        })
+
+                        const statusResult = {
+                            projectName,
+                            provider: 'vercel.com',
+                            status: 'READY'
+                        }
+                        await this.$StatusFact.set(projectName, statusResult)
+                    }
+                },
+                status: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config, now, passive, deploymentName }: { config: any; now?: boolean; passive?: boolean; deploymentName?: string }) {
+                        const projectName = config.provider.config.ProjectSettings.name
+                        const factName = deploymentName || projectName
+
+                        if (!projectName) {
+                            return {
+                                projectName: factName || 'unknown',
+                                provider: 'vercel.com',
+                                error: 'No project name configured',
+                                rawDefinitionFilepaths: []
+                            }
+                        }
+
+                        // Raw fact filepaths that this status depends on
+                        const rawFilepaths = [
+                            this.$ProjectDeploymentFact.getRelativeFilepath(projectName)
+                        ]
+
+                        // Try to get cached status if not forcing refresh
+                        if (!now) {
+                            const cached = await this.$StatusFact.get(factName, rawFilepaths)
+                            if (cached) {
+                                return cached.data
+                            }
+                        }
+
+                        // In passive mode, don't call the provider if no cache exists
+                        if (passive) {
+                            return null
+                        }
+
+                        const projectDetails = await this.project.get({
+                            name: projectName
+                        })
+
+                        if (!projectDetails) {
+                            const errorResult = {
+                                projectName: factName,
+                                provider: 'vercel.com',
+                                error: 'Project not found',
+                                rawDefinitionFilepaths: rawFilepaths
+                            }
+                            await this.$StatusFact.set(factName, errorResult)
+                            return errorResult
+                        }
+
+                        const statusTeam = await this.project.vercel.getDefaultTeam()
+                        const deploymentsResponse = await (await this.project.vercel.vercel).deployments.getDeployments({
+                            projectId: projectDetails.id,
+                            teamId: await this.project.vercel.orgIdForName({
+                                name: statusTeam
+                            }),
+                            limit: 1
+                        })
+
+                        const latestDeployment = deploymentsResponse.deployments?.[0]
+
+                        const statusMap: Record<string, string> = {
+                            'READY': 'READY',
+                            'BUILDING': 'BUILDING',
+                            'ERROR': 'ERROR',
+                            'CANCELED': 'ERROR',
+                            'QUEUED': 'BUILDING'
+                        }
+
+                        const result: Record<string, any> = {
+                            projectName: factName,
+                            provider: 'vercel.com',
+                            status: statusMap[latestDeployment?.readyState] || 'UNKNOWN',
+                            publicUrl: latestDeployment?.url ? `https://${latestDeployment.url}` : undefined,
+                            createdAt: latestDeployment?.createdAt ? new Date(latestDeployment.createdAt).toISOString() : undefined,
+                            updatedAt: latestDeployment?.aliasAssigned ? new Date(latestDeployment.aliasAssigned).toISOString() : undefined,
+                            providerProjectId: projectDetails.id,
+                            providerPortalUrl: latestDeployment?.inspectorUrl,
+                            rawDefinitionFilepaths: rawFilepaths
+                        }
+
+                        await this.$StatusFact.set(factName, result)
+
+                        return result
+                    }
+                },
+                deprovision: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config }: { config: any }) {
+
+                        const projectName = config.provider.config.ProjectSettings.name
+
+                        console.log(`Deprovisioning project '${projectName}' from Vercel ...`)
+
+                        try {
+                            // Get project details to verify it exists
+                            const details = await this.project.get({
+                                name: projectName
+                            })
+
+                            if (!details) {
+                                console.log(`Project '${projectName}' not found on Vercel. Nothing to deprovision.`)
+                                return
+                            }
+
+                            console.log(`Found project ID: ${details.id}`)
+
+                            // Delete the project
+                            const deprovisionTeam = await this.project.vercel.getDefaultTeam()
+                            await (await this.project.vercel.vercel).projects.deleteProject({
+                                idOrName: details.id,
+                                slug: deprovisionTeam
+                            })
+
+                            console.log(`Successfully deleted project '${projectName}' from Vercel.`)
+
+                            // Delete fact files
+                            console.log(`Deleting fact files ...`)
+                            try {
+                                await this.$ProjectDeploymentFact.delete(projectName)
+                                await this.$StatusFact.delete(projectName)
+                                console.log(`Fact files deleted`)
+                            } catch (error: any) {
+                                console.log(`Error deleting fact files: ${error.message}`)
+                            }
+
+                        } catch (error: any) {
+                            if (error.message?.includes('not found') || error.status === 404) {
+                                console.log(`Project '${projectName}' not found on Vercel. Nothing to deprovision.`)
+
+                                // Still delete fact files even if project not found
+                                console.log(`Deleting fact files ...`)
+                                try {
+                                    await this.$ProjectDeploymentFact.delete(projectName)
+                                    await this.$StatusFact.delete(projectName)
+                                    console.log(`Fact files deleted`)
+                                } catch (factError: any) {
+                                    console.log(`Error deleting fact files: ${factError.message}`)
+                                }
+                            } else {
+                                throw error
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/vercel.com/ProjectDeployment'

package/caps/providers/vercel.com/api.test.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env bun test
+
+export const testConfig = {
+    group: 'vendor',
+    runOnAll: false,
+}
+
+import * as bunTest from 'bun:test'
+import { run } from '@t44/t44/workspace-rt'
+
+const {
+    test: { describe, it, expect },
+    vercel
+} = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceTest',
+                    options: {
+                        '#': {
+                            bunTest,
+                            env: {
+                                VERCEL_TOKEN: { factReference: 't44/structs/providers/vercel.com/WorkspaceConnectionConfig:apiToken' }
+                            }
+                        }
+                    }
+                },
+                vercel: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api'
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: 't44/caps/providers/vercel.com/api.test'
+    })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, {
+    importMeta: import.meta
+})
+
+describe('Vercel SDK', function () {
+
+    it('getTeams()', async function () {
+
+        const result = await vercel.getTeams()
+
+        expect(result).toBeObject()
+        expect(result.teams).toBeArray()
+    })
+
+    it('getProjects()', async function () {
+
+        const result = await vercel.getProjects()
+
+        expect(result).toBeObject()
+        expect(result.projects).toBeArray()
+    })
+
+})