Merge pull request #6 from KilleenCode/support-rc5-updater

support tauri >=v1.0.0-rc.5 urls, routing with fallback to legacy

Author: RyKilleen

src/constants.ts

@@ -1,6 +1,41 @@
 export enum AVAILABLE_PLATFORMS {
   MacOS = 'darwin',
-  Win32 = 'win32',
-  Win64 = 'win64',
+  Windows = 'windows',
   Linux = 'linux',
 }
+
+export enum AVAILABLE_ARCHITECTURES {
+  x64 = 'x86_64',
+  x86 = 'i686',
+  arm64 = 'aarch64',
+  armv7 = 'armv7',
+}
+
+//TODO: check if this is correct
+export const ARCH_FILTERS = {
+  [AVAILABLE_ARCHITECTURES.x64]: ['x64', 'amd64'],
+  [AVAILABLE_ARCHITECTURES.x86]: ['x86'],
+  [AVAILABLE_ARCHITECTURES.arm64]: ['arm64'],
+  [AVAILABLE_ARCHITECTURES.armv7]: ['armv7'],
+} as { [key in AVAILABLE_ARCHITECTURES]: string[] }
+
+export type Filter = {
+  extension: string
+  matches: string[]
+}
+export const PLATFORM_FILTERS = {
+  [AVAILABLE_PLATFORMS.MacOS]: {
+    extension: 'gz',
+    matches: ['.app', 'osx'],
+  },
+  [AVAILABLE_PLATFORMS.Windows]: {
+    extension: 'zip',
+    matches: ['x64', 'x32'],
+  },
+  [AVAILABLE_PLATFORMS.Linux]: {
+    extension: 'gz',
+    matches: ['AppImage'],
+  },
+} as {
+  [key in AVAILABLE_PLATFORMS]: Filter
+}

src/getPlatform.ts

@@ -1,92 +1,29 @@
-import { AVAILABLE_PLATFORMS } from './constants'
-
-export function sanitizeVersion(version: string): string | undefined {
-  // if it start with app-name-v1.0.0, get the version.
-  // If there is a string name, assume a `v` char.
-  const semanticV = version.split('v').pop()
-
-  return semanticV
-}
-
-export function checkPlatform(
-  platform: string,
+import {
+  ARCH_FILTERS,
+  AVAILABLE_ARCHITECTURES,
+  AVAILABLE_PLATFORMS,
+  PLATFORM_FILTERS,
+} from './constants'
+import { fileExt } from './utils/fileExt'
+
+export const testAsset = (
+  target: AVAILABLE_PLATFORMS,
+  arch: AVAILABLE_ARCHITECTURES,
   fileName: string,
-): string | undefined {
-  const extension = extname(fileName)
-  // OSX we should have our .app tar.gz
-  if (
-    (fileName.includes('.app') ||
-      fileName.includes('darwin') ||
-      fileName.includes('osx')) &&
-    extension === 'gz' &&
-    platform === AVAILABLE_PLATFORMS.MacOS
-  ) {
-    return 'darwin'
-  }
-
-  // Windows 64 bits
-  if (
-    (fileName.includes('x64') || fileName.includes('win64')) &&
-    extension === 'zip' &&
-    platform === AVAILABLE_PLATFORMS.Win64
-  ) {
-    return 'win64'
+): boolean => {
+  const { matches, extension } = PLATFORM_FILTERS[target]
+  const arch_matches = ARCH_FILTERS[arch]
+  const rightArch =
+    arch_matches && ARCH_FILTERS[arch].some((arch) => fileName.includes(arch))
+
+  // .app gz files don't have arch in the name
+  if (!rightArch && target !== AVAILABLE_PLATFORMS.MacOS) {
+    return false
   }
 
-  // Windows 32 bits
-  if (
-    (fileName.includes('x32') || fileName.includes('win32')) &&
-    extension === 'zip' &&
-    platform === AVAILABLE_PLATFORMS.Win32
-  ) {
-    return 'win32'
+  if (fileExt(fileName) !== extension) {
+    return false
   }
 
-  // Linux app image
-  if (
-    fileName.includes('AppImage') &&
-    extension === 'gz' &&
-    platform === AVAILABLE_PLATFORMS.Linux
-  ) {
-    return 'linux'
-  }
-}
-
-function extname(filename: string) {
-  return filename.split('.').pop() || ''
-}
-
-export type Asset = { name: string; browser_download_url: string }
-
-export async function findAssetSignature(
-  fileName: string,
-  assets: Asset[],
-): Promise<string | undefined> {
-  // check in our assets if we have a file: `fileName.sig`
-  // by example fileName can be: App-1.0.0.zip
-
-  const foundSignature = assets.find(
-    (asset) => asset.name.toLowerCase() === `${fileName.toLowerCase()}.sig`,
-  )
-
-  if (!foundSignature) {
-    return undefined
-  }
-
-  const response = await fetch(foundSignature.browser_download_url)
-  if (response.status !== 200) {
-    return undefined
-  }
-  const signature = await response.text()
-  return signature
-}
-
-export function validatePlatform(platform: string): string | undefined {
-  switch (platform) {
-    case AVAILABLE_PLATFORMS.MacOS:
-    case AVAILABLE_PLATFORMS.Win32:
-    case AVAILABLE_PLATFORMS.Win64:
-    case AVAILABLE_PLATFORMS.Linux:
-      return platform
-  }
+  return matches.some((match) => fileName.includes(match))
 }

src/handler.ts

@@ -1,82 +1,86 @@
-import {
-  Asset,
-  checkPlatform,
-  findAssetSignature,
-  sanitizeVersion,
-  validatePlatform,
-} from './getPlatform'
+import { testAsset } from './getPlatform'
 import semverValid from 'semver/functions/valid'
 import semverGt from 'semver/functions/gt'
-
-type TauriUpdateResponse = {
-  url: string
-  version: string
-  notes?: string
-  pub_date?: string
-  signature?: string
-}
+import { AVAILABLE_ARCHITECTURES, AVAILABLE_PLATFORMS } from './constants'
+import { handleLegacyRequest } from './legacy/handler'
+import { findAssetSignature, getLatestRelease } from './services/github'
+import { TauriUpdateResponse } from './types'
+import { sanitizeVersion } from './utils/versioning'
 
 declare global {
   const GITHUB_ACCOUNT: string
   const GITHUB_REPO: string
 }
 
-export async function handleRequest(request: Request): Promise<Response> {
-  const path = new URL(request.url).pathname
-  const [platform, version] = path.slice(1).split('/')
+const responses = {
+  NotFound: () => new Response('Not found', { status: 404 }),
+  NoContent: () => new Response(null, { status: 204 }),
+  SendUpdate: (data: TauriUpdateResponse) =>
+    new Response(JSON.stringify(data), {
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+    }),
+}
 
-  const reqUrl = new URL(
-    `https://api.github.com/repos/${GITHUB_ACCOUNT}/${GITHUB_REPO}/releases/latest`,
-  )
-  const headers = new Headers({
-    Accept: 'application/vnd.github.preview',
-    'User-Agent': request.headers.get('User-Agent') as string,
-  })
-  const releaseResponse = await fetch(reqUrl.toString(), {
-    method: 'GET',
-    headers,
-  })
+type RequestPathParts = [
+  string,
+  AVAILABLE_PLATFORMS,
+  AVAILABLE_ARCHITECTURES,
+  string,
+]
+const handleV1Request = async (request: Request) => {
+  const path = new URL(request.url).pathname
+  const [, target, arch, appVersion] = path
+    .slice(1)
+    .split('/') as RequestPathParts
 
-  const release = (await releaseResponse.clone().json()) as {
-    tag_name: string
-    assets: Asset[]
-    body: string
-    published_at: string
-  }
-  if (!platform || !validatePlatform(platform) || !version) {
-    return releaseResponse
+  if (!target || !arch || !appVersion || !semverValid(appVersion)) {
+    return responses.NotFound()
   }
-  const remoteVersion = sanitizeVersion(release.tag_name.toLowerCase())
+  const release = await getLatestRelease(request)
 
+  const remoteVersion = sanitizeVersion(release.tag_name.toLowerCase())
   if (!remoteVersion || !semverValid(remoteVersion)) {
-    return new Response('Not found', { status: 404 })
+    return responses.NotFound()
   }
 
-  const shouldUpdate = semverGt(remoteVersion, version)
+  const shouldUpdate = semverGt(remoteVersion, appVersion)
   if (!shouldUpdate) {
-    return new Response(null, { status: 204 })
+    return responses.NoContent()
   }
 
-  for (const asset of release.assets) {
-    const { name, browser_download_url } = asset
-    const findPlatform = checkPlatform(platform, name)
-    if (!findPlatform) {
-      continue
-    }
+  const match = release.assets.find(({ name }) => {
+    const test = testAsset(target, arch, name)
 
-    // try to find signature for this asset
-    const signature = await findAssetSignature(name, release.assets)
-    const data: TauriUpdateResponse = {
-      url: browser_download_url,
-      version: remoteVersion,
-      notes: release.body,
-      pub_date: release.published_at,
-      signature,
+    return test
+  })
+
+  if (typeof match === 'undefined') {
+    return responses.NotFound()
+  }
+
+  const signature = await findAssetSignature(match.name, release.assets)
+  const data: TauriUpdateResponse = {
+    url: match.browser_download_url,
+    version: remoteVersion,
+    notes: release.body,
+    pub_date: release.published_at,
+    signature,
+  }
+
+  return responses.SendUpdate(data)
+}
+
+export async function handleRequest(request: Request): Promise<Response> {
+  const path = new URL(request.url).pathname
+  const version = path.slice(1).split('/')[0]
+
+  if (version.includes('v')) {
+    switch (version) {
+      case 'v1':
+      default:
+        return handleV1Request(request)
     }
-    return new Response(JSON.stringify(data), {
-      headers: { 'Content-Type': 'application/json; charset=utf-8' },
-    })
   }
 
-  return new Response(JSON.stringify({ remoteVersion, version, shouldUpdate }))
+  return handleLegacyRequest(request)
 }

src/legacy/checkPlatform.ts

@@ -0,0 +1,46 @@
+import { LEGACY_AVAILABLE_PLATFORMS } from './constants'
+import { fileExt } from '../utils/fileExt'
+
+export function checkPlatform(
+  platform: string,
+  fileName: string,
+): string | undefined {
+  const extension = fileExt(fileName)
+  // OSX we should have our .app tar.gz
+  if (
+    (fileName.includes('.app') ||
+      fileName.includes('darwin') ||
+      fileName.includes('osx')) &&
+    extension === 'gz' &&
+    platform === LEGACY_AVAILABLE_PLATFORMS.MacOS
+  ) {
+    return 'darwin'
+  }
+
+  // Windows 64 bits
+  if (
+    (fileName.includes('x64') || fileName.includes('win64')) &&
+    extension === 'zip' &&
+    platform === LEGACY_AVAILABLE_PLATFORMS.Win64
+  ) {
+    return 'win64'
+  }
+
+  // Windows 32 bits
+  if (
+    (fileName.includes('x32') || fileName.includes('win32')) &&
+    extension === 'zip' &&
+    platform === LEGACY_AVAILABLE_PLATFORMS.Win32
+  ) {
+    return 'win32'
+  }
+
+  // Linux app image
+  if (
+    fileName.includes('AppImage') &&
+    extension === 'gz' &&
+    platform === LEGACY_AVAILABLE_PLATFORMS.Linux
+  ) {
+    return 'linux'
+  }
+}

src/legacy/constants.ts

@@ -0,0 +1,6 @@
+export enum LEGACY_AVAILABLE_PLATFORMS {
+  MacOS = 'darwin',
+  Win32 = 'win32',
+  Win64 = 'win64',
+  Linux = 'linux',
+}