zarro 1.164.0 → 1.165.2

package/gulp-tasks/modules/fetch-github-release/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "fetch-github-release",
+  "version": "1.0.0",
+  "description": "Fetch binary from Github releases for your platform",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/valerybugakov/fetch-github-release.git"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "prepublishOnly": "npm ci && run-s build test",
+    "test": "jest",
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "format": "run-s format:fix:*",
+    "format:ci": "run-s format:check:*",
+    "format:check:lint": "cross-env eslint $npm_package_config_eslint",
+    "format:fix:lint": "cross-env eslint --fix $npm_package_config_eslint",
+    "format:check:prettier": "cross-env prettier --check $npm_package_config_prettier",
+    "format:fix:prettier": "cross-env prettier --write $npm_package_config_prettier",
+    "prepare": "husky install"
+  },
+  "config": {
+    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 src/**/*.{ts,js,html} *.{ts,js,html} .*.{ts,js,html}",
+    "prettier": "--ignore-path .gitignore --loglevel=warn {src,tests,.github}/**/*.{ts,js,md,yml,json,html} *.{ts,js,yml,json,html} .*.{ts,js,yml,json,html} !package-lock.json"
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
+      "pre-push": "npm run format"
+    }
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "keywords": [
+    "github",
+    "binary",
+    "release",
+    "fetch",
+    "get"
+  ],
+  "author": "Valery Bugakov <skymk1@gmail.com> (https://github.com/valerybugakov/)",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.15.0",
+    "@commitlint/cli": "^17.6.7",
+    "@commitlint/config-conventional": "^17.6.7",
+    "@types/download": "^8.0.0",
+    "@types/jest": "^26.0.0",
+    "@types/node": "^14.0.0",
+    "@types/semver": "^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.27.0",
+    "@typescript-eslint/parser": "^4.27.0",
+    "cross-env": "^7.0.3",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.24.1",
+    "eslint-plugin-prettier": "^3.4.1",
+    "expect-even-more-jest": "^1.18.0",
+    "filesystem-sandbox": "^1.24.0",
+    "husky": "^7.0.0",
+    "jest": "^27.0.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "ts-jest": "^27.0.0",
+    "typescript": "^4.0.0"
+  },
+  "dependencies": {
+    "@octokit/rest": "^18.9.1",
+    "bent": "^7.3.12",
+    "decompress": "^4.2.1",
+    "semver": "^7.5.4",
+    "yafs": "^1.27.0"
+  }
+}

package/gulp-tasks/modules/fetch-github-release/renovate.json5

@@ -0,0 +1,19 @@
+{
+  force: {
+    constraints: {
+      node: '< 15.0.0',
+    },
+  },
+  extends: ['config:base', 'schedule:weekly'],
+  rangeStrategy: 'update-lockfile',
+  automerge: true,
+  major: {
+    automerge: false,
+  },
+  lockFileMaintenance: {
+    enabled: true,
+  },
+  ignorePresets: [':prHourlyLimit2'],
+  semanticCommits: true,
+  dependencyDashboard: true,
+}

package/gulp-tasks/modules/fetch-github-release/src/__tests__/index.ts

@@ -0,0 +1,51 @@
+import "expect-even-more-jest";
+import { newerVersion, listReleases, fetchLatestRelease } from "../"
+import { Sandbox } from "filesystem-sandbox";
+import { ls } from "yafs";
+
+describe(`newerVersion`, () => {
+  it("should compare versions", () => {
+    expect(newerVersion("0.1.0", "0.0.1")).toBe(true)
+    expect(newerVersion("v0.1.0", "v0.0.1")).toBe(true)
+    expect(newerVersion("v0.0.1", "")).toBe(true)
+
+    expect(newerVersion("0.0.1", "0.0.1")).toBe(false)
+    expect(newerVersion("v0.0.1", "v0.0.1")).toBe(false)
+    expect(newerVersion("", "0.0.1")).toBe(false)
+  });
+});
+
+describe(`listReleases`, () => {
+  it(`should find releases`, async () => {
+    // Arrange
+    // Act
+    const result = await listReleases({ owner: "fluffynuts", repo: "NExpect" });
+    // Assert
+    expect(result)
+      .not.toBeEmptyArray();
+  });
+});
+
+describe(`fetchLatestRelease`, () => {
+  it(`should fetch and unpack`, async () => {
+    // Arrange
+    const
+      os = require("os"),
+      isWindows = os.platform() === "win32",
+      sandbox = await Sandbox.create();
+    // Act
+    await fetchLatestRelease({
+      destination: sandbox.path,
+      owner: "axllent",
+      repo: "mailpit"
+    });
+    // Assert
+    const contents = await ls(sandbox.path);
+    expect(contents)
+      .toContain(
+        isWindows
+          ? "mailpit.exe"
+          : "mailpit"
+      );
+  });
+});

package/gulp-tasks/modules/fetch-github-release/src/constants.ts

@@ -0,0 +1,5 @@
+import os from 'os'
+import path from 'path'
+
+export const PACKAGE_NAME = 'fetch-github-release'
+export const PACKAGE_DATA_DIR = path.join(os.homedir(), `.${PACKAGE_NAME}`)

package/gulp-tasks/modules/fetch-github-release/src/fetchRelease.ts

@@ -0,0 +1,159 @@
+import { writeFile, rm } from "yafs";
+import path from 'path'
+
+import { Octokit } from '@octokit/rest'
+import decompress from 'decompress'
+const bent = require("bent");
+
+import { PACKAGE_DATA_DIR } from './constants'
+import { OctokitRelease, OctokitReleaseAssets, RepoInfo } from './types'
+import { ensureDirExist } from './util'
+import { getAssetDefault } from './getAssetDefault'
+
+export interface FetchReleaseOptions extends RepoInfo {
+  getRelease: (owner: string, repo: string) => Promise<OctokitRelease>
+  getAsset?: (
+    version: string,
+    assets: OctokitReleaseAssets,
+  ) => OctokitReleaseAssets[number] | undefined
+  accessToken?: string
+  destination?: string
+  shouldExtract?: boolean
+}
+
+type AsyncFunction<T> = () => Promise<T>;
+type AsyncVoidFunction = AsyncFunction<void>;
+interface Dictionary<T> {
+  [key: string]: T;
+}
+
+interface BentResponse {
+  statusCode: number;
+  json: AsyncFunction<any>;
+  text: AsyncFunction<string>;
+  arrayBuffer: AsyncFunction<Buffer>;
+  headers: Dictionary<string>;
+}
+
+function determineFilenameFrom(response: BentResponse): string {
+  const contentDisposition = response.headers["content-disposition"];
+  if (!contentDisposition) {
+    // guess? shouldn't get here from GH queries...
+    return fallback();
+  }
+  const parts = contentDisposition.split(";").map(s => s.trim());
+  for (const part of parts) {
+    let match = part.match(/^filename=(?<filename>.+)/i);
+    if (match && match.groups) {
+      const filename = match.groups["filename"];
+      if (filename) {
+        return filename;
+      }
+    }
+  }
+  return fallback();
+
+  function fallback() {
+    console.warn(`Unable to determine filename from request, falling back on release.zip`);
+    return "release.zip";
+  }
+}
+
+async function download(url: string, destination: string): Promise<string> {
+  const fetch = bent(url);
+  try {
+    const response = await fetch();
+    const data = await response.arrayBuffer();
+    const filename = determineFilenameFrom(response);
+    await writeFile(path.join(destination, filename), data);
+    return determineFilenameFrom(response);
+  } catch (e) {
+    const err = e as BentResponse;
+    if (err.statusCode === undefined) {
+      throw err;
+    }
+    if (err.statusCode === 301 || err.statusCode === 302) {
+      const next = err.headers["location"];
+      if (!next) {
+        throw new Error(`No location provided for http response ${err.statusCode}`);
+      }
+      return download(next, destination);
+    }
+    throw err;
+  }
+}
+
+async function fetchRelease(options: FetchReleaseOptions): Promise<string[]> {
+  const {
+    owner,
+    repo,
+    getRelease,
+    getAsset = getAssetDefault,
+    destination = PACKAGE_DATA_DIR,
+    shouldExtract = true,
+  } = options
+
+  if (!owner) {
+    throw new Error('Required "owner" option is missing')
+  }
+
+  if (!repo) {
+    throw new Error('Required "repo" option is missing')
+  }
+
+  const {
+    data: { assets, tag_name: version },
+  } = await getRelease(owner, repo)
+  const downloadUrl = getAsset(version, assets)?.browser_download_url
+
+  if (!downloadUrl) {
+    throw new Error('Unable to find download URL')
+  }
+
+  await ensureDirExist(destination)
+  const filename = await download(downloadUrl, destination)
+  const downloadPath = path.join(destination, filename)
+
+  if (shouldExtract) {
+    const files = await decompress(downloadPath, destination)
+    await rm(downloadPath)
+
+    return files.map((file: decompress.File) => path.join(destination, file.path))
+  }
+
+  return [downloadPath]
+}
+
+/**
+ * Downloads and extract release for the specified tag from Github to the destination.
+ *
+ * await fetchLatestRelease({ owner: 'smallstep', repo: 'cli', tag: '1.0.0' })
+ */
+export async function fetchReleaseByTag(
+  options: Omit<FetchReleaseOptions, 'getRelease'> & { tag: string },
+): Promise<string[]> {
+  return fetchRelease({
+    ...options,
+    getRelease: (owner, repo) =>
+      new Octokit({ auth: options.accessToken }).repos.getReleaseByTag({
+        owner,
+        repo,
+        tag: options.tag,
+      }),
+  })
+}
+
+/**
+ * Downloads and extract latest release from Github to the destination.
+ *
+ * await fetchLatestRelease({ owner: 'smallstep', repo: 'cli' })
+ */
+export async function fetchLatestRelease(
+  options: Omit<FetchReleaseOptions, 'getRelease'>,
+): Promise<string[]> {
+  return fetchRelease({
+    ...options,
+    getRelease: (owner, repo) =>
+      new Octokit({ auth: options.accessToken }).repos.getLatestRelease({ owner, repo }),
+  })
+}

package/gulp-tasks/modules/fetch-github-release/src/getAssetDefault.ts

@@ -0,0 +1,48 @@
+import { OctokitReleaseAssets } from './types'
+
+interface PlatformIdentifier {
+  platform: string
+  arch: string
+}
+
+function getPlatformIdentifier(): PlatformIdentifier {
+  switch (process.platform) {
+    case 'win32':
+      return { platform: 'windows', arch: 'amd64' }
+    case 'linux':
+      if (process.arch === 'arm64') {
+        return { platform: 'linux', arch: 'arm64' }
+      }
+
+      if (process.arch === 'arm') {
+        return { platform: 'linux', arch: 'arm' }
+      }
+
+      return { platform: 'linux', arch: 'amd64' }
+    case 'darwin':
+      return { platform: 'darwin', arch: 'amd64' }
+    default:
+      throw new Error('Unsupported platform')
+  }
+}
+
+export function getAssetDefault(
+  version: string,
+  assets: OctokitReleaseAssets,
+): OctokitReleaseAssets[number] {
+  const { platform, arch } = getPlatformIdentifier()
+
+  const platformAssets = assets.filter((asset: { name: string }) => asset.name.includes(platform))
+
+  if (platformAssets.length === 1) {
+    return platformAssets[0]
+  }
+
+  const archAsset = platformAssets.find((asset: { name: string }) => asset.name.includes(arch))
+
+  if (!archAsset) {
+    throw new Error(`Unable to find release for platform: ${platform} and arch: ${arch}`)
+  }
+
+  return archAsset
+}

package/gulp-tasks/modules/fetch-github-release/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./fetchRelease";
+export * from "./isUpdateAvailable";

package/gulp-tasks/modules/fetch-github-release/src/isUpdateAvailable.ts

@@ -0,0 +1,143 @@
+import { Octokit } from "@octokit/rest"
+import { gt } from "semver"
+
+import { RepoInfo } from "./types"
+
+interface IsUpdateAvailableOptions extends RepoInfo {
+  currentVersion: string
+  accessToken?: string
+}
+
+export async function isUpdateAvailable(options: IsUpdateAvailableOptions): Promise<boolean> {
+  const { repo, owner, currentVersion, accessToken } = options
+  const {
+    data: { tag_name: latestVersion },
+  } = await new Octokit({ auth: accessToken }).repos.getLatestRelease({ owner, repo })
+
+  return newerVersion(latestVersion, currentVersion)
+}
+
+export interface FetchLatestReleaseOptions extends RepoInfo {
+  accessToken?: string;
+}
+
+export interface FetchLatestReleaseResult {
+  url: string;
+  id: number;
+  assets: any[];
+  name: string | null;
+  body?: string | null;
+  assets_url: string;
+  author: string;
+  body_html: string;
+  body_text: string;
+  created_at: string;
+  discussion_url: string;
+  draft: boolean;
+  html_url: string;
+  mentions_count: number;
+}
+
+export async function fetchLatestReleaseInfo(
+    opts: ListReleasesOptions
+): Promise<ReleaseInfo> {
+  const { repo, owner, accessToken } = opts;
+  const result = await new Octokit({ auth: accessToken }).repos.getLatestRelease({ owner, repo });
+  return result.data as ReleaseInfo;
+}
+
+export interface ListReleasesOptions extends RepoInfo {
+  accessToken?: string;
+}
+
+export interface AuthorInfo {
+  login: string;
+  id: number;
+  node_id: string;
+  avatar_url: string;
+  gravatar_id: string;
+  url: string;
+  html_url: string;
+  followers_url: string;
+  following_url: string;
+  gists_url: string;
+  starred_url: string;
+  subscriptions_url: string;
+  organizations_url: string;
+  repos_url: string;
+  events_url: string;
+  received_events_url: string;
+  type: string;
+  site_admin: boolean;
+}
+
+export interface ReleaseAsset {
+  url: string;
+  id: number;
+  node_id: string;
+  name: string;
+  label: string;
+  uploader: AuthorInfo;
+  content_type: string;
+  state: string;
+  size: number;
+  download_count: number;
+  created_at: string;
+  updated_at: string;
+  browser_download_url: string;
+}
+
+export interface ReleaseReactions {
+  url: string;
+  total_count: number;
+  "+1": number;
+  "-1": number;
+  laugh: number;
+  hooray: number;
+  confused: number;
+  heart: number;
+  rocket: number;
+  eyes: number;
+}
+
+export interface ReleaseInfo {
+  url: string;
+  assets_url: string;
+  upload_url: string;
+  html_url: string;
+  author: AuthorInfo;
+  node_id: string;
+  tag_name: string;
+  tag_commitish?: string;
+  name: string;
+  draft: boolean;
+  prerelease: boolean;
+  created_at: string;
+  published_at: string;
+  assets: ReleaseAsset[];
+  tarball_url: string;
+  zipball_url: string;
+  body: string;
+  reactions: ReleaseReactions
+}
+
+export async function listReleases(opts: ListReleasesOptions): Promise<ReleaseInfo[]> {
+  const { repo, owner, accessToken } = opts;
+  const result = await new Octokit({ auth: accessToken }).repos.listReleases({ owner, repo });
+  return result.data as ReleaseInfo[];
+}
+
+export function newerVersion(latestVersion: string, currentVersion: string): boolean {
+  if (!latestVersion) {
+    return false
+  }
+
+  if (!currentVersion) {
+    return true
+  }
+
+  const normalizedLatestVersion = latestVersion.replace(/^v/, "")
+  const normalizedCurrentVersion = currentVersion.replace(/^v/, "")
+
+  return gt(normalizedLatestVersion, normalizedCurrentVersion)
+}

package/gulp-tasks/modules/fetch-github-release/src/types.ts

@@ -0,0 +1,17 @@
+import { RestEndpointMethodTypes } from '@octokit/rest'
+
+export type OctokitRelease = RestEndpointMethodTypes['repos']['getLatestRelease']['response']
+export type OctokitReleaseAssets = OctokitRelease['data']['assets']
+
+export interface Release {
+  repository: string
+  package: string
+  destination: string
+  version: string
+  extract: boolean
+}
+
+export interface RepoInfo {
+  owner: string
+  repo: string
+}

package/gulp-tasks/modules/fetch-github-release/src/util.ts

@@ -0,0 +1,24 @@
+import fs from 'fs'
+import path from 'path'
+
+export const exists = async (filePath: string): Promise<boolean> => {
+  try {
+    await fs.promises.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const mkdir = async (dirname: string): Promise<void> => {
+  const isExist = await exists(dirname)
+
+  if (!isExist) {
+    await fs.promises.mkdir(dirname, { recursive: true })
+  }
+}
+
+export const ensureDirExist = async (filePath: string): Promise<void> => {
+  const dirname = path.dirname(filePath)
+  await mkdir(dirname)
+}

package/gulp-tasks/modules/increment-version.js

@@ -19,7 +19,7 @@
         "patch": 2
     };
     module.exports = function incrementVersion(version, strategy, zeroLowerOrder = true, incrementBy = 1) {
-        const dashedParts = version.split("-"), currentVersionIsPreRelease = dashedParts.length > 1, parts = dashedParts[0].split(".").map(i => parseInt(i));
+        const dashedParts = version.split("-"), currentVersionIsPreRelease = dashedParts.length > 1, prefix = removePrefix(dashedParts), parts = dashedParts[0].split(".").map(i => parseInt(i));
         let toIncrement = incrementLookup[(strategy || "").toLowerCase()];
         if (toIncrement === undefined) {
             throw new ZarroError(`Unknown version increment strategy: ${strategy}\n try one of 'major', 'minor' or 'patch'`);
@@ -43,8 +43,17 @@
         }
         const result = parts.join(".");
         if (strategy != "prerelease") {
-            return result;
+            return `${prefix}${result}`;
         }
-        return `${result}-${generateVersionSuffix()}`;
+        return `${prefix}${result}-${generateVersionSuffix()}`;
     };
+    function removePrefix(parts) {
+        var _a, _b, _c;
+        const match = parts[0].match(/^(?<prefix>[^.\d]+)?(?<version>[.\d]+)/), prefix = (_b = (_a = match === null || match === void 0 ? void 0 : match.groups) === null || _a === void 0 ? void 0 : _a["prefix"]) !== null && _b !== void 0 ? _b : "", version = (_c = match === null || match === void 0 ? void 0 : match.groups) === null || _c === void 0 ? void 0 : _c["version"];
+        if (!version) {
+            throw new Error(`'${parts[0]}' doesn't look like a version string?`);
+        }
+        parts[0] = version;
+        return prefix;
+    }
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.164.0",
+  "version": "1.165.2",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"
@@ -91,6 +91,7 @@
   },
   "files": [
     "gulp-tasks/**/*.js",
+    "gulp-tasks/modules/fetch-github-release/**/*.*",
     "index-modules/**/*.js",
     "types.d.ts",
     "tsconfig.json"