@foundation0/git 1.0.0 → 1.2.1

package/packages/git/src/platform/config.ts

@@ -1,140 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-
-export type PlatformName = 'GITEA' | 'GITHUB'
-
-export interface GitPlatformConfig {
-  platform: PlatformName
-  giteaHost: string
-  giteaToken?: string
-  giteaApiVersion?: string
-  giteaSwaggerPath?: string
-}
-
-interface DotEnv {
-  [key: string]: string
-}
-
-const DEFAULT_GITEA_HOST = 'https://gitea.example.com'
-const DEFAULT_PLATFORM: PlatformName = 'GITEA'
-const DEFAULT_GITEA_SWAGGER_PATH = '/swagger.v1.json'
-
-const parseLine = (line: string): [string, string] | null => {
-  const trimmed = line.trim()
-  if (!trimmed || trimmed.startsWith('#')) {
-    return null
-  }
-
-  const index = trimmed.indexOf('=')
-  if (index < 0) {
-    return null
-  }
-
-  const key = trimmed.slice(0, index).trim()
-  const rawValue = trimmed.slice(index + 1).trim()
-  if (!key) {
-    return null
-  }
-
-  if (rawValue.length >= 2 && rawValue.startsWith('"') && rawValue.endsWith('"')) {
-    return [key, rawValue.slice(1, -1)]
-  }
-
-  if (rawValue.length >= 2 && rawValue.startsWith("'") && rawValue.endsWith("'")) {
-    return [key, rawValue.slice(1, -1)]
-  }
-
-  return [key, rawValue]
-}
-
-const readDotEnv = (filePath: string): DotEnv => {
-  if (!existsSync(filePath)) {
-    return {}
-  }
-
-  const env: DotEnv = {}
-
-  const contents = readFileSync(filePath, 'utf8')
-  for (const line of contents.split(/\r?\n/)) {
-    const parsed = parseLine(line)
-    if (!parsed) {
-      continue
-    }
-
-    const [key, value] = parsed
-    env[key] = value
-  }
-
-  return env
-}
-
-const searchDotEnv = (): DotEnv => {
-  const candidates = [
-    join(process.cwd(), '.env'),
-    join(dirname(process.cwd()), '.env'),
-  ]
-
-  for (const candidate of candidates) {
-    const values = readDotEnv(candidate)
-    if (Object.keys(values).length > 0) {
-      return values
-    }
-  }
-
-  return {}
-}
-
-const normalizePlatform = (value?: string): PlatformName => {
-  const platform = (value ?? '').toUpperCase()
-  if (platform === 'GITEA') {
-    return 'GITEA'
-  }
-
-  if (platform === 'GITHUB') {
-    return 'GITHUB'
-  }
-
-  return DEFAULT_PLATFORM
-}
-
-export const getGitPlatformConfig = (overrides: Partial<GitPlatformConfig> = {}): GitPlatformConfig => {
-  const env = searchDotEnv()
-
-  const platform = normalizePlatform(
-    overrides.platform ??
-      process.env.PLATFORM ??
-      process.env.GIT_PLATFORM ??
-      env.PLATFORM ??
-      env.GIT_PLATFORM,
-  )
-
-  const giteaHost =
-    overrides.giteaHost ??
-    process.env.GITEA_HOST ??
-    env.GITEA_HOST ??
-    DEFAULT_GITEA_HOST
-
-  const giteaToken =
-    overrides.giteaToken ??
-    process.env.GITEA_TOKEN ??
-    env.GITEA_TOKEN
-
-  const giteaApiVersion =
-    overrides.giteaApiVersion ??
-    process.env.GITEA_API_VERSION ??
-    env.GITEA_API_VERSION
-
-  const giteaSwaggerPath =
-    overrides.giteaSwaggerPath ??
-    process.env.GITEA_SWAGGER_PATH ??
-    env.GITEA_SWAGGER_PATH ??
-    DEFAULT_GITEA_SWAGGER_PATH
-
-  return {
-    platform,
-    giteaHost,
-    giteaToken,
-    giteaApiVersion,
-    giteaSwaggerPath,
-  }
-}

package/packages/git/tests/api.spec.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createRemoteGitApiClient, GIT_API_VERSION } from '../src'
-
-describe('remote Git API client', () => {
-  it('builds default response that matches the mock contract', () => {
-    const client = createRemoteGitApiClient()
-    const response = client.request({
-      path: ['repos', 'owner', 'repo', 'issues', '123'],
-      query: ['state=open'],
-      headers: ['Accept: application/vnd.github+json'],
-    })
-
-    expect(response).toEqual({
-      endpoint: 'https://api.github.com/repos/owner/repo/issues/123',
-      method: 'GET',
-      path: ['repos', 'owner', 'repo', 'issues', '123'],
-      query: ['state=open'],
-      headers: ['Accept: application/vnd.github+json'],
-      requestParts: [
-        'GET',
-        'repos',
-        'owner',
-        'repo',
-        'issues',
-        '123',
-        'state=open',
-        'Accept: application/vnd.github+json',
-      ],
-      apiVersion: GIT_API_VERSION,
-    })
-  })
-
-  it('supports API base, version, and async request custom defaults', async () => {
-    const client = createRemoteGitApiClient({
-      apiBase: 'https://internal.example.com',
-      apiVersion: '2022-11-28-preview',
-      defaultMethod: 'POST',
-    })
-    const response = await client.requestAsync({
-      method: 'PATCH',
-      path: ['repos', 'owner', 'repo', 'issues', '999'],
-    })
-
-    expect(response).toEqual({
-      endpoint: 'https://internal.example.com/repos/owner/repo/issues/999',
-      method: 'PATCH',
-      path: ['repos', 'owner', 'repo', 'issues', '999'],
-      query: [],
-      headers: [],
-      requestParts: ['PATCH', 'repos', 'owner', 'repo', 'issues', '999'],
-      apiVersion: '2022-11-28-preview',
-    })
-  })
-})

package/packages/git/tests/e2e/git-service-feature-e2e.spec.ts

@@ -1,232 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import swaggerSpec from '../../gitea-swagger.json'
-import { getGitPlatformConfig } from '../../src/platform/config'
-
-interface SwaggerParameter {
-  name?: string
-  in?: string
-  required?: boolean
-  schema?: {
-    type?: string
-    enum?: unknown[]
-    format?: string
-  }
-}
-
-interface SwaggerOperation {
-  parameters?: SwaggerParameter[]
-}
-
-interface SwaggerPathEntry {
-  [method: string]: SwaggerOperation | undefined
-  parameters?: SwaggerParameter[]
-}
-
-interface SwaggerOperationCase {
-  pathTemplate: string
-  method: string
-  resolvedPath: string
-}
-
-const normalizePlatformHost = (host: string): string => {
-  const trimmed = host.replace(/\/$/, '')
-  if (trimmed.endsWith('/api/v1')) {
-    return trimmed
-  }
-
-  return `${trimmed}/api/v1`
-}
-
-const platformConfig = getGitPlatformConfig({ platform: 'GITEA' })
-const host = normalizePlatformHost(platformConfig.giteaHost)
-const apiToken = platformConfig.giteaToken
-const testOwner = process.env.GITEA_TEST_OWNER ?? 'example-org'
-const testRepo = process.env.GITEA_TEST_REPO ?? 'example-repo'
-
-const defaultValueFor = (name: string, schema?: SwaggerParameter['schema']): string => {
-  const normalized = name.toLowerCase()
-
-  if (schema?.type === 'integer' || schema?.type === 'number') {
-    return '1'
-  }
-
-  if (schema?.type === 'boolean') {
-    return 'true'
-  }
-
-  if (schema?.enum && schema.enum.length > 0) {
-    return String(schema.enum[0])
-  }
-
-  if (normalized === 'owner' || normalized === 'org' || normalized === 'organization' || normalized === 'user' || normalized === 'username') {
-    return testOwner
-  }
-
-  if (normalized === 'repo' || normalized === 'repository') {
-    return testRepo
-  }
-
-  if (normalized === 'archive' || normalized.includes('archive')) {
-    return 'zip'
-  }
-
-  if (normalized === 'difftype' || normalized.includes('diff') || normalized.includes('diff-type')) {
-    return 'patch'
-  }
-
-  if (normalized.includes('filepath') || normalized.includes('file-path') || normalized.includes('path') || normalized.includes('filename')) {
-    return 'README.md'
-  }
-
-  if (normalized.includes('pagename') || normalized.includes('page-name')) {
-    return 'readme'
-  }
-
-  if (normalized.includes('sha') || normalized.includes('branch') || normalized.includes('ref')) {
-    return 'main'
-  }
-
-  if (normalized.includes('number') || /[id]/.test(normalized) || normalized.includes('id') || normalized.includes('index') || normalized.includes('tag_id')) {
-    return '1'
-  }
-
-  if (normalized.includes('tag') || normalized.includes('release')) {
-    return 'v1'
-  }
-
-  if (normalized.includes('name') || normalized.includes('title') || normalized.includes('secretname') || normalized.includes('username')) {
-    return 'sample'
-  }
-
-  return '1'
-}
-
-const getPathDefaults = (pathTemplate: string, pathItem: SwaggerPathEntry, operation: SwaggerOperation): Record<string, string> => {
-  const parameterDefs = new Map<string, SwaggerParameter>()
-
-  for (const parameter of [...(pathItem.parameters ?? []), ...(operation.parameters ?? [])]) {
-    if (!parameter?.name) {
-      continue
-    }
-
-    if (parameter.in === 'path') {
-      parameterDefs.set(parameter.name, parameter)
-    }
-  }
-
-  const placeholders = new Set<string>()
-  const pattern = /\{([^}]+)\}/g
-  let match: RegExpExecArray | null = null
-
-  while ((match = pattern.exec(pathTemplate)) !== null) {
-    placeholders.add(match[1])
-  }
-
-  const defaults: Record<string, string> = {}
-  for (const placeholder of placeholders) {
-    const definition = parameterDefs.get(placeholder)
-    defaults[placeholder] = defaultValueFor(placeholder, definition?.schema)
-  }
-
-  return defaults
-}
-
-const resolvePath = (pathTemplate: string, defaults: Record<string, string>): string =>
-  pathTemplate.replace(/\{([^}]+)\}/g, (_match, key: string) => {
-    const value = defaults[key] ?? '1'
-    return encodeURIComponent(value)
-  })
-
-const buildSwaggerCases = (): SwaggerOperationCase[] => {
-  const cases: SwaggerOperationCase[] = []
-
-  const paths = swaggerSpec.paths as Record<string, SwaggerPathEntry> | undefined
-  if (!paths) {
-    return cases
-  }
-
-  const sortedPaths = Object.keys(paths).sort()
-  for (const pathTemplate of sortedPaths) {
-    const pathItem = paths[pathTemplate]
-    if (!pathItem || typeof pathItem !== 'object') {
-      continue
-    }
-
-    const methods = Object.keys(pathItem).filter(
-      (method) => method !== 'parameters' && typeof (pathItem as Record<string, unknown>)[method] === 'object',
-    )
-
-    for (const method of methods.sort()) {
-      const operation = pathItem[method]
-      if (!operation || typeof operation !== 'object') {
-        continue
-      }
-
-      const defaults = getPathDefaults(pathTemplate, pathItem, operation)
-      const resolvedPath = resolvePath(pathTemplate, defaults)
-
-      cases.push({
-        pathTemplate,
-        method: method.toUpperCase(),
-        resolvedPath,
-      })
-    }
-  }
-
-  return cases
-}
-
-const headers: Record<string, string> = {
-  Accept: 'application/json',
-}
-
-if (apiToken) {
-  headers.Authorization = `token ${apiToken}`
-}
-
-const swaggerCases = buildSwaggerCases()
-
-const getAllowedStatuses = (method: string): number[] => {
-  const normalizedMethod = method.toUpperCase()
-  if (normalizedMethod === 'GET') {
-    return [200, 201, 204, 301, 302, 304, 400, 401, 403, 404, 405, 409, 422, 429]
-  }
-
-  if (normalizedMethod === 'POST') {
-    return [200, 201, 202, 204, 400, 401, 403, 404, 405, 409, 422, 429]
-  }
-
-  if (normalizedMethod === 'PATCH' || normalizedMethod === 'PUT') {
-    return [200, 201, 202, 204, 400, 401, 403, 404, 405, 409, 422, 429]
-  }
-
-  if (normalizedMethod === 'DELETE') {
-    return [200, 202, 204, 400, 401, 403, 404, 405, 409, 422, 429]
-  }
-
-  if (normalizedMethod === 'HEAD') {
-    return [200, 204, 301, 302, 304, 401, 403, 404]
-  }
-
-  return [200, 201, 204, 400, 401, 403, 404, 405, 422, 429]
-}
-
-describe('e2e git service API coverage from swagger', () => {
-  it('reads host configuration', () => {
-    expect(host).toMatch(/^https?:\/\/.+/)
-  })
-
-  for (const caseSpec of swaggerCases) {
-    const label = `${caseSpec.method} ${caseSpec.pathTemplate}`
-    it(`hits ${label}`, async () => {
-      const response = await fetch(`${host}${caseSpec.resolvedPath}`, {
-        method: caseSpec.method,
-        headers,
-      })
-
-      expect(response.status).toBeLessThan(500)
-      expect(getAllowedStatuses(caseSpec.method)).toContain(response.status)
-    })
-  }
-})

package/packages/git/tests/git-service-api-object.spec.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { createGitServiceApi } from '../src'
-
-describe('gitServiceApi object', () => {
-  it('exposes repo.issue.create and posts issue payload', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          id: 1,
-          number: 5,
-          title: 'Hello',
-          html_url: 'http://gitea.example.com/example-org/example-repo/issues/5',
-        }),
-        { status: 201, headers: { 'content-type': 'application/json' } },
-      ),
-    )
-
-    const api = createGitServiceApi({
-      config: {
-        platform: 'GITEA',
-        giteaHost: 'https://gitea.example.com',
-        giteaToken: 'token',
-      },
-      defaultOwner: 'example-org',
-      defaultRepo: 'example-repo',
-    })
-
-    expect(typeof api.repo).toBe('object')
-    expect(typeof (api.repo as Record<string, unknown>).issue).toBe('object')
-    expect(typeof (api.repo as Record<string, unknown>).issue.create).toBe('function')
-
-    const result = await (api.repo as Record<string, any>).issue.create({
-      data: {
-        title: 'Hello',
-        body: 'world',
-      },
-    })
-
-    expect(fetchSpy).toHaveBeenCalledTimes(1)
-
-    const [requestUrl, requestInit] = fetchSpy.mock.calls[0]
-    expect(requestUrl).toBe('https://gitea.example.com/api/v1/repos/example-org/example-repo/issues')
-    expect(requestInit?.method).toBe('POST')
-
-    expect(JSON.parse(requestInit?.body as string)).toEqual({
-      title: 'Hello',
-      body: 'world',
-    })
-
-    expect(result.status).toBe(201)
-    expect(result.body).toEqual({
-      id: 1,
-      number: 5,
-      title: 'Hello',
-      html_url: 'http://gitea.example.com/example-org/example-repo/issues/5',
-    })
-
-    fetchSpy.mockRestore()
-  })
-
-  it('aborts requests when requestTimeoutMs elapses', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(
-      (_url: any, init?: any) =>
-        new Promise((_resolve, reject) => {
-          const signal = init?.signal as AbortSignal | undefined
-          if (signal?.aborted) {
-            reject(new DOMException('Aborted', 'AbortError'))
-            return
-          }
-          signal?.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')))
-        }) as any,
-    )
-
-    const api = createGitServiceApi({
-      config: {
-        platform: 'GITEA',
-        giteaHost: 'https://gitea.example.com',
-        giteaToken: 'token',
-      },
-      defaultOwner: 'example-org',
-      defaultRepo: 'example-repo',
-      requestTimeoutMs: 5,
-    })
-
-    await expect(
-      (api.repo as Record<string, any>).issue.create({
-        data: {
-          title: 'Hello',
-          body: 'world',
-        },
-      }),
-    ).rejects.toThrow(/Request timed out after 5ms:/)
-
-    fetchSpy.mockRestore()
-  })
-})

package/packages/git/tests/git-service-feature-matrix.spec.ts

@@ -1,182 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import swaggerSpec from '../gitea-swagger.json'
-import { GIT_API_VERSION, buildGitApiMockResponse, createGitPlatformAdapter, type GitApiFeatureContext } from '../src'
-import { gitServiceFeatureSpec } from '../src/git-service-feature-spec.generated'
-import { getGitPlatformConfig } from '../src/platform/config'
-
-interface FeatureMatrixCase {
-  path: string[]
-  args: string[]
-  flagValues: Record<string, string | boolean | undefined>
-}
-
-const parseArgumentValue = (argument: string): string | null => {
-  const trimmed = argument.trim()
-  if (!trimmed) {
-    return null
-  }
-
-  if (trimmed.startsWith('-') || trimmed === '[flags]') {
-    return null
-  }
-
-  const firstAlternative = trimmed.split('|')[0].trim()
-  if (!firstAlternative) {
-    return null
-  }
-
-  const value = firstAlternative
-    .replace(/^\[/, '')
-    .replace(/\]$/, '')
-    .replace(/^\{/, '')
-    .replace(/\}$/, '')
-    .replace(/^</, '')
-    .replace(/>$/, '')
-    .replace(/\.\.\.$/, '')
-    .trim()
-
-  if (!value || value.startsWith('-')) {
-    return null
-  }
-
-  return value
-}
-
-const buildArgCases = (path: string[], args: string[]): FeatureMatrixCase[] => {
-  const values = args
-    .map((arg) => parseArgumentValue(arg))
-    .filter((value): value is string => value !== null)
-
-  if (values.length === 0) {
-    return [{ path, args: [], flagValues: {} }]
-  }
-
-  const cases: FeatureMatrixCase[] = []
-  for (let index = 0; index < values.length; index += 1) {
-    cases.push({ path, args: values.slice(0, index + 1), flagValues: {} })
-  }
-
-  return cases
-}
-
-const buildFlagCase = (path: string[], args: string[], flag: { name: string; takesValue: boolean }): FeatureMatrixCase => ({
-  path,
-  args: args.map((arg) => parseArgumentValue(arg)).filter((value): value is string => value !== null),
-  flagValues: {
-    [flag.name]: flag.takesValue ? 'value' : true,
-  },
-})
-
-const platformConfig = getGitPlatformConfig({
-  platform: 'GITEA',
-})
-const testRepoOwner = process.env.GITEA_TEST_OWNER ?? 'example-org'
-const testRepoName = process.env.GITEA_TEST_REPO ?? 'example-repo'
-
-const adapter = createGitPlatformAdapter({
-  config: platformConfig,
-  swaggerSpec,
-})
-
-const prependTestRepoArgs = (args: string[]) => [testRepoOwner, testRepoName, ...args]
-
-const expectedResponse = (
-  mappingPath: string[],
-  mappingMethod: string,
-  query: string[],
-  headers: string[],
-  apiBase: string,
-  apiVersion?: string,
-) =>
-  buildGitApiMockResponse({
-    path: mappingPath,
-    method: mappingMethod,
-    query,
-    headers,
-    apiBase,
-    apiVersion,
-  })
-
-describe('git service feature matrix', () => {
-  it('is populated from the generated feature spec', () => {
-    expect(gitServiceFeatureSpec.features.length).toBeGreaterThan(0)
-  })
-
-  for (const feature of gitServiceFeatureSpec.features) {
-    const label = feature.path.join(' ')
-    const featureContext = (args: string[], flagValues: FeatureMatrixCase['flagValues']): GitApiFeatureContext => ({
-      feature,
-      args,
-      flagValues,
-    })
-
-    const argumentCases = buildArgCases(feature.path, feature.args)
-
-    for (const [index, currentCase] of argumentCases.entries()) {
-      const title =
-        currentCase.args.length === 0
-          ? `maps ${label} with no arguments`
-          : `maps ${label} with first ${index + 1} argument(s)`
-
-      it(title, async () => {
-        const testArgs = prependTestRepoArgs(currentCase.args)
-        const mapped = await adapter.mapFeature(featureContext(testArgs, currentCase.flagValues))
-        const response = await adapter.mapFeatureResponse(featureContext(testArgs, currentCase.flagValues))
-
-        expect(response).toEqual(
-          expectedResponse(
-            mapped.mappedPath,
-            mapped.method,
-            mapped.query,
-            mapped.headers,
-            mapped.apiBase,
-            mapped.apiVersion ?? GIT_API_VERSION,
-          ),
-        )
-      })
-    }
-
-    for (const flag of feature.flags) {
-      const currentCase = buildFlagCase(feature.path, feature.args, flag)
-      const title = `maps ${label} with flag ${flag.name}${flag.takesValue ? '=value' : ''}`
-
-      it(title, async () => {
-        const testArgs = prependTestRepoArgs(currentCase.args)
-        const mapped = await adapter.mapFeature(featureContext(testArgs, currentCase.flagValues))
-        const response = await adapter.mapFeatureResponse(featureContext(testArgs, currentCase.flagValues))
-
-        expect(response).toEqual(
-          expectedResponse(
-            mapped.mappedPath,
-            mapped.method,
-            mapped.query,
-            mapped.headers,
-            mapped.apiBase,
-            mapped.apiVersion ?? GIT_API_VERSION,
-          ),
-        )
-      })
-    }
-
-    it(`${label} validates against local swagger spec`, async () => {
-      const args = feature.args
-        .map((arg) => parseArgumentValue(arg))
-        .filter((value): value is string => value !== null)
-        .slice(0, 2)
-      const testArgs = prependTestRepoArgs(args)
-
-      const validation = await adapter.validateFeature(featureContext(testArgs, {}))
-
-      const response = await adapter.mapFeatureResponse(featureContext(testArgs, {}))
-
-      expect(response.endpoint).toBe(`${validation.apiBase}/${validation.mappedPath.join('/')}`)
-      expect(response.path).toEqual(validation.mappedPath)
-      if (validation.mapped) {
-        expect(validation.reason).toBeUndefined()
-      } else {
-        expect(validation.reason).toBeTruthy()
-      }
-    })
-  }
-})