bleam 0.0.10 → 0.0.11

package/templates/updates/src/schema.ts

@@ -1,4 +1,4 @@
-export type ArtifactFormat = 'bleam-ota-zip-v1' | 'bleam-macos-app-zip-v1'
+export type ArtifactFormat = 'bleam-ota-zip-v1'
 
 export interface StoredArtifact {
   format: ArtifactFormat
@@ -11,43 +11,24 @@ export interface ResolvedArtifact extends StoredArtifact {
   url: string
 }
 
-interface ReleaseFields {
+export interface OtaRelease {
   schemaVersion: 1
+  kind: 'ota'
   bundleIdentifier: string
   teamIdentifier: string
   channel: 'stable'
   releaseId: string
-  publishedAt: string
-}
-
-export interface OtaRelease extends ReleaseFields {
-  kind: 'ota'
   bundleVersion: string
   runtimeVersion: string
   artifact: StoredArtifact & { format: 'bleam-ota-zip-v1' }
+  publishedAt: string
 }
 
-export interface PlatformRelease extends ReleaseFields {
-  kind: 'platform'
-  appVersion: string
-  buildNumber: string
-  bleamPlatformVersion: string
-  platformFingerprint?: string
-  redeploy: boolean
-  target: {
-    os: 'macos'
-    architecture: 'arm64'
-    installLocation: 'user-applications'
-    minimumMacOSVersion: string
-  }
-  artifact: StoredArtifact & { format: 'bleam-macos-app-zip-v1' }
-}
-
-export type StoredRelease = OtaRelease | PlatformRelease
+export type StoredRelease = OtaRelease
 
-export type ResolvedRelease =
-  | (Omit<OtaRelease, 'artifact'> & { artifact: ResolvedArtifact })
-  | (Omit<PlatformRelease, 'artifact'> & { artifact: ResolvedArtifact })
+export type ResolvedRelease = Omit<OtaRelease, 'artifact'> & {
+  artifact: ResolvedArtifact
+}
 
 export interface DownloadRecord {
   schemaVersion: 1
@@ -104,23 +85,6 @@ function version(value: unknown, field: string): string {
   return result
 }
 
-function numericString(value: unknown, field: string): string {
-  const result = string(value, field)
-  if (!/^\d+$/.test(result)) {
-    return invalid(field, 'must contain only decimal digits')
-  }
-  return result
-}
-
-function optionalSha256(value: unknown, field: string): string | undefined {
-  if (value === undefined) return undefined
-  const result = string(value, field)
-  if (!/^[a-f0-9]{64}$/.test(result)) {
-    return invalid(field, 'must be a lowercase SHA-256 hex digest')
-  }
-  return result
-}
-
 function publishedAt(value: unknown): string {
   const result = string(value, 'publishedAt')
   if (
@@ -140,44 +104,6 @@ export function isRuntimeVersion(value: string): boolean {
   return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value)
 }
 
-export function compareRuntimeVersions(left: string, right: string) {
-  const parse = (value: string) => {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(value)
-    if (!match) return invalid('runtimeVersion', 'must be a semantic version')
-    return {
-      core: match.slice(1, 4).map(Number),
-      prerelease: match[4]?.split('.'),
-    }
-  }
-  const a = parse(left)
-  const b = parse(right)
-  for (let index = 0; index < a.core.length; index += 1) {
-    if (a.core[index] !== b.core[index]) {
-      return (a.core[index] ?? 0) < (b.core[index] ?? 0) ? -1 : 1
-    }
-  }
-  if (!a.prerelease && !b.prerelease) return 0
-  if (!a.prerelease) return 1
-  if (!b.prerelease) return -1
-  const length = Math.max(a.prerelease.length, b.prerelease.length)
-  for (let index = 0; index < length; index += 1) {
-    const aPart = a.prerelease[index]
-    const bPart = b.prerelease[index]
-    if (aPart === undefined) return -1
-    if (bPart === undefined) return 1
-    if (aPart === bPart) continue
-    const aNumber = /^\d+$/.test(aPart) ? Number(aPart) : undefined
-    const bNumber = /^\d+$/.test(bPart) ? Number(bPart) : undefined
-    if (aNumber !== undefined && bNumber !== undefined) {
-      return aNumber < bNumber ? -1 : 1
-    }
-    if (aNumber !== undefined) return -1
-    if (bNumber !== undefined) return 1
-    return aPart < bPart ? -1 : 1
-  }
-  return 0
-}
-
 export function isDownloadId(value: string): boolean {
   return /^[a-z][a-z0-9_-]{2,127}$/.test(value)
 }
@@ -209,11 +135,9 @@ function teamIdentifier(value: unknown): string {
   return result
 }
 
-function artifact(value: unknown, kind: StoredRelease['kind']): StoredArtifact {
+function artifact(value: unknown): StoredArtifact {
   const input = record(value, 'artifact')
-  const expectedFormat =
-    kind === 'ota' ? 'bleam-ota-zip-v1' : 'bleam-macos-app-zip-v1'
-  exactString(input.format, 'artifact.format', expectedFormat)
+  exactString(input.format, 'artifact.format', 'bleam-ota-zip-v1')
 
   const downloadId = string(input.downloadId, 'artifact.downloadId')
   if (!isDownloadId(downloadId)) {
@@ -229,113 +153,34 @@ function artifact(value: unknown, kind: StoredRelease['kind']): StoredArtifact {
   }
 
   return {
-    format: expectedFormat,
+    format: 'bleam-ota-zip-v1',
     downloadId,
     sizeBytes: positiveInteger(input.sizeBytes, 'artifact.sizeBytes'),
     sha256,
   }
 }
 
-function releaseFields(input: Record<string, unknown>): ReleaseFields {
+export function parseStoredRelease(value: unknown): StoredRelease {
+  const input = record(value, 'manifest')
   if (input.schemaVersion !== 1) {
     return invalid('schemaVersion', 'must be 1')
   }
-
+  exactString(input.kind, 'kind', 'ota')
   exactString(input.channel, 'channel', 'stable')
   return {
     schemaVersion: 1,
+    kind: 'ota',
     bundleIdentifier: bundleIdentifier(input.bundleIdentifier),
     teamIdentifier: teamIdentifier(input.teamIdentifier),
     channel: 'stable',
     releaseId: releaseId(input.releaseId),
+    bundleVersion: string(input.bundleVersion, 'bundleVersion'),
+    runtimeVersion: version(input.runtimeVersion, 'runtimeVersion'),
+    artifact: artifact(input.artifact),
     publishedAt: publishedAt(input.publishedAt),
   }
 }
 
-export function parseStoredRelease(value: unknown): StoredRelease {
-  const input = record(value, 'manifest')
-  const kind = string(input.kind, 'kind')
-  const fields = releaseFields(input)
-
-  if (kind === 'ota') {
-    const parsedArtifact = artifact(input.artifact, kind)
-    return {
-      ...fields,
-      kind,
-      bundleVersion: string(input.bundleVersion, 'bundleVersion'),
-      runtimeVersion: version(input.runtimeVersion, 'runtimeVersion'),
-      artifact: {
-        ...parsedArtifact,
-        format: 'bleam-ota-zip-v1',
-      },
-    }
-  }
-
-  if (kind === 'platform') {
-    const target = record(input.target, 'target')
-    exactString(target.os, 'target.os', 'macos')
-    exactString(target.architecture, 'target.architecture', 'arm64')
-    exactString(
-      target.installLocation,
-      'target.installLocation',
-      'user-applications',
-    )
-    const minimumMacOSVersion = string(
-      target.minimumMacOSVersion,
-      'target.minimumMacOSVersion',
-    )
-    if (!/^\d+(?:\.\d+){0,2}$/.test(minimumMacOSVersion)) {
-      return invalid(
-        'target.minimumMacOSVersion',
-        'must be a macOS version number',
-      )
-    }
-
-    const parsedArtifact = artifact(input.artifact, kind)
-    return {
-      ...fields,
-      kind,
-      appVersion: version(input.appVersion, 'appVersion'),
-      buildNumber: numericString(input.buildNumber, 'buildNumber'),
-      bleamPlatformVersion: version(
-        input.bleamPlatformVersion,
-        'bleamPlatformVersion',
-      ),
-      platformFingerprint: optionalSha256(
-        input.platformFingerprint,
-        'platformFingerprint',
-      ),
-      redeploy: input.redeploy === true,
-      target: {
-        os: 'macos',
-        architecture: 'arm64',
-        installLocation: 'user-applications',
-        minimumMacOSVersion,
-      },
-      artifact: {
-        ...parsedArtifact,
-        format: 'bleam-macos-app-zip-v1',
-      },
-    }
-  }
-
-  return invalid('kind', 'must be "ota" or "platform"')
-}
-
-export function parsePublishedRelease(value: unknown): StoredRelease {
-  const release = parseStoredRelease(value)
-  if (release.kind !== 'platform') return release
-
-  const input = record(value, 'manifest')
-  if (release.platformFingerprint === undefined) {
-    return invalid('platformFingerprint', 'is required')
-  }
-  if (typeof input.redeploy !== 'boolean') {
-    return invalid('redeploy', 'must be a boolean')
-  }
-  return release
-}
-
 export function parseDownloadRecord(value: unknown): DownloadRecord {
   const input = record(value, 'download record')
   if (input.schemaVersion !== 1) {