(.*?)<\/div>/)?.[1];
28 | const updateAt = text.match(/
(.*?)<\/div>/)?.[1];
29 |
30 | return {
31 | version: version || null,
32 | releasedAt: (new Date()).toISOString(),
33 | updateAt: updateAt || "",
34 | notes: notes || "",
35 | url: `https://play.google.com/store/apps/details?id=${bundleId}&hl=${country}`,
36 | lastChecked: (new Date()).toISOString()
37 | };
38 | };
39 |
--------------------------------------------------------------------------------
/src/providers/ios.js:
--------------------------------------------------------------------------------
1 | export const getIosVersion = async (bundleId, country) => {
2 | // Adds a random number to the end of the URL to prevent caching
3 | const url = `https://itunes.apple.com/lookup?bundleId=${bundleId}&country=${country}&_=${new Date().valueOf()}`;
4 |
5 | let res = await fetch(url);
6 |
7 | const data = await res.json();
8 |
9 | if (!data || !("results" in data)) {
10 | throw new Error("Unknown error connecting to iTunes.");
11 | }
12 | if (!data.results.length) {
13 | throw new Error("App for this bundle ID not found.");
14 | }
15 |
16 | res = data.results[0];
17 |
18 | return {
19 | version: res.version || null,
20 | released: res.currentVersionReleaseDate || res.releaseDate || null,
21 | notes: res.releaseNotes || "",
22 | url: res.trackViewUrl || res.artistViewUrl || res.sellerUrl || null,
23 | country,
24 | lastChecked: (new Date()).toISOString()
25 | };
26 | };
27 |
--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
1 | import { getIosVersion } from "./providers/ios";
2 | import { getAndroidVersion } from "./providers/android";
3 |
4 | export const lookupVersion = async(platform, bundleId, country = "us") => {
5 | switch (platform) {
6 | case "ios":
7 | return getIosVersion(bundleId, country);
8 | case "android":
9 | return getAndroidVersion(bundleId, country);
10 | default:
11 | throw new Error("Unsupported platform defined.");
12 | }
13 | };
14 |
--------------------------------------------------------------------------------
/src/versions.js:
--------------------------------------------------------------------------------
1 | import semver from "semver";
2 |
3 | export const parseVersion = (version) => {
4 | return semver.parse(semver.coerce(version), true);
5 | };
6 |
7 | export const diffLoose = (version1, version2) => {
8 | if (version1 === version2) {
9 | return null;
10 | }
11 |
12 | const v1 = parseVersion(version1);
13 | const v2 = parseVersion(version2);
14 | if (semver.lt(v2, v1) || semver.eq(v1, v2, true)) {
15 | return null;
16 | }
17 |
18 | let prefix = "";
19 | let defaultResult = null;
20 | if (v1.prerelease.length || v2.prerelease.length) {
21 | prefix = "pre";
22 | defaultResult = "prerelease";
23 | }
24 | for (let key in v1) {
25 | if (v1.hasOwnProperty(key) && ["major", "minor", "patch"].includes(key) && v1[key] !== v2[key]) {
26 | return prefix + key;
27 | }
28 | }
29 | return defaultResult;
30 | };
31 |
32 | export const versionCompare = (currentVersion, latestVersion) => {
33 | if (!latestVersion) {
34 | return {
35 | needsUpdate: false,
36 | updateType: null,
37 | notice: "Error: could not get latest version"
38 | };
39 | }
40 |
41 | try {
42 | const updateType = diffLoose(currentVersion, latestVersion);
43 | return {
44 | needsUpdate: !!updateType,
45 | updateType
46 | };
47 | } catch (e) {
48 | let needsUpdate = currentVersion !== latestVersion && (latestVersion > currentVersion);
49 | if (!latestVersion.includes(".") || latestVersion.split(".").length < 3) {
50 | // Not a valid semver, so don't ever ask to update
51 | needsUpdate = false;
52 | }
53 | const updateType = needsUpdate ? "minor" : null;
54 | return {
55 | needsUpdate,
56 | updateType,
57 | notice: e.message.replace(/^Invalid Version:/, "Not a valid semver version:")
58 | };
59 | }
60 | };
61 |
--------------------------------------------------------------------------------
/tests/index.test.js:
--------------------------------------------------------------------------------
1 | import { checkVersion } from "../index";
2 |
3 | global.fetch = jest.requireActual('node-fetch')
4 |
5 | describe("checkVersion", () => {
6 | test("can get version for valid bundle ID for Android", async () => {
7 | const data = await checkVersion({
8 | platform: "android",
9 | bundleId: "com.streetartcities.map",
10 | currentVersion: "1.0.0"
11 | });
12 |
13 | expect(data.platform).toEqual("android");
14 | expect(data.bundleId).toEqual("com.streetartcities.map");
15 | expect(data.needsUpdate).toEqual(true);
16 | });
17 |
18 | test("can get version for unknown bundle ID for Android with error property", async () => {
19 | const data = await checkVersion({
20 | platform: "android",
21 | bundleId: "com.notarealapp.unknown",
22 | currentVersion: "1.0.0"
23 | });
24 |
25 | expect(data.platform).toEqual("android");
26 | expect(data.bundleId).toEqual("com.notarealapp.unknown");
27 | expect(data.error.toString()).toEqual('Error: App with bundle ID "com.notarealapp.unknown" not found in Google Play.');
28 | });
29 |
30 |
31 | test("can get version for valid bundle ID for iOS", async () => {
32 | const data = await checkVersion({
33 | platform: "ios",
34 | bundleId: "nl.hoyapp.mobile",
35 | currentVersion: "1.0.0"
36 | });
37 |
38 | expect(data.platform).toEqual("ios");
39 | expect(data.bundleId).toEqual("nl.hoyapp.mobile");
40 | expect(data.needsUpdate).toEqual(true);
41 | });
42 |
43 | test("can get version for unknown bundle ID for iOS with error property", async () => {
44 | const data = await checkVersion({
45 | platform: "ios",
46 | bundleId: "com.notarealapp.unknown",
47 | currentVersion: "1.0.0"
48 | });
49 |
50 | expect(data.platform).toEqual("ios");
51 | expect(data.bundleId).toEqual("com.notarealapp.unknown");
52 | expect(data.error.toString()).toEqual("Error: App for this bundle ID not found.");
53 | });
54 | });
55 |
--------------------------------------------------------------------------------
/tests/version.test.js:
--------------------------------------------------------------------------------
1 | import { versionCompare } from "../src/versions";
2 |
3 | describe("Version compare", () => {
4 | it("deals with real semvers", () => {
5 | expect(versionCompare("1.1.2", "1.1.3")).toEqual({
6 | needsUpdate: true,
7 | updateType: "patch"
8 | });
9 | expect(versionCompare("1.1.2", "1.1.2")).toEqual({
10 | needsUpdate: false,
11 | updateType: null
12 | });
13 | expect(versionCompare("1.2.0", "1.1.3")).toEqual({
14 | needsUpdate: false,
15 | updateType: null
16 | });
17 | expect(versionCompare("1.1.1", "1.2.0")).toEqual({
18 | needsUpdate: true,
19 | updateType: "minor"
20 | });
21 | expect(versionCompare("0.9.0", "1.2.0")).toEqual({
22 | needsUpdate: true,
23 | updateType: "major"
24 | });
25 | });
26 |
27 | it("deals with simple decimal versions", () => {
28 | expect(versionCompare("1.1", "1.2")).toEqual({
29 | needsUpdate: true,
30 | updateType: "minor"
31 | });
32 | expect(versionCompare("1.1", "1.1")).toEqual({
33 | needsUpdate: false,
34 | updateType: null
35 | });
36 | expect(versionCompare("1.2", "1.1")).toEqual({
37 | needsUpdate: false,
38 | updateType: null
39 | });
40 | expect(versionCompare("0.9", "1.2")).toEqual({
41 | needsUpdate: true,
42 | updateType: "major"
43 | });
44 | });
45 |
46 | it("deals with single-number versions", () => {
47 | expect(versionCompare("11", "12")).toEqual({
48 | needsUpdate: true,
49 | updateType: "major"
50 | });
51 | expect(versionCompare("11", "11")).toEqual({
52 | needsUpdate: false,
53 | updateType: null
54 | });
55 | expect(versionCompare("12", "11")).toEqual({
56 | needsUpdate: false,
57 | updateType: null
58 | });
59 | expect(versionCompare("9", "12")).toEqual({
60 | needsUpdate: true,
61 | updateType: "major"
62 | });
63 | expect(versionCompare("944", "1201")).toEqual({
64 | needsUpdate: true,
65 | updateType: "major"
66 | });
67 | });
68 | });
69 |
--------------------------------------------------------------------------------