Update export

Author: Sirherobrine23

.github/workflows/search_versions.yaml

@@ -57,14 +57,10 @@ jobs:
         with:
           node-version: 18.x
 
-      - name: Install Index-pages
-        run: sudo npm i -g index-pages@latest
+      - run: npm ci
 
       - name: Update files
-        run: node static_version.mjs
-
-      - name: Create index.html
-        run: apindex versions/
+        run: npm run export
 
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v1

package-lock.json

@@ -18,7 +18,7 @@
   "scripts": {
     "dev": "nodemon -e ts,js -w src/**/* src/api.ts",
     "search": "ts-node src/fetchVersion/index.ts",
-    "export": "ts-node src/export.ts",
+    "export": "ts-node src/exports.ts && apindex versions/",
     "build": "tsc"
   },
   "repository": {
@@ -52,6 +52,7 @@
     "@types/yargs": "^17.0.11",
     "adm-zip": "^0.5.9",
     "cli-color": "^2.0.3",
+    "index-pages": "^1.0.4",
     "nodemon": "^2.0.19",
     "ts-node": "^10.9.1",
     "typescript": "^4.7.4"

package.json

@@ -23,8 +23,20 @@ app.get("/", ({res}) => paper.find().lean().then(data => res.json(data)));
 app.get("/latest", ({res}) => paper.findOne({latest: true}).lean().then(data => res.json(data)));
 app.get("/search", async (req, res) => {
   let version = req.query.version as string;
-  if (!version) return res.status(400).json({error: "No version specified"});
-  const versionDB = await paper.findOne({version}).lean();
-  if (!versionDB) return res.status(404).json({error: "Version not found"});
-  return res.json(versionDB);
+  if (!version) return res.status(400).json({erro: "Not allowd blank version"});
+  let build = parseInt(req.query.build as string);
+  if (isNaN(build)) build = undefined;
+  if (!!build) {
+    const info = await paper.findOne({
+      version,
+      build
+    });
+    if (!info) return res.status(400).json({error: "version and build not exists"});
+    return res.json(info);
+  }
+  const info = await paper.findOne({
+    version
+  });
+  if (!info) return res.status(400).json({error: "version not exists"});
+  return res.json(info);
 });

src/db/paper.ts

@@ -1,20 +1,76 @@
-import * as path from "node:path";
-import { writeFile } from "node:fs/promises";
-import { bedrock } from "./db/bedrock";
-import { java } from "./db/java";
-import { pocketmine } from "./db/pocketmine";
-import { spigot } from "./db/spigot";
-import { powernukkit } from "./db/powernukkit";
-import { paper } from "./db/paper";
-
-const exportVersions = () => Promise.all([
-  bedrock.find().lean(),
-  java.find().lean(),
-  pocketmine.find().lean(),
-  spigot.find().lean(),
-  paper.find().lean(),
-  powernukkit.find().lean()
-]).then(([bedrock, java, pocketmine, spigot, paper, powernukkit]) => JSON.stringify({bedrock, java, pocketmine, spigot, paper, powernukkit}, (key, value)=>key==="__v"?undefined:key==="_id"?undefined:value, 2));
-
-const outputFile = process.env.OUTPUT?path.resolve(process.env.OUTPUT):path.join(process.cwd(), "versions.json");
-exportVersions().then(res => writeFile(outputFile, /\.md$/.test(outputFile)?`#Result\n\n\`\`\`json\n${res}\n\`\`\`\n`:res)).then(() => {console.log("File save in '%s' path.", outputFile); process.exit(0)});
+import fsOld from "node:fs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { findVersion as getVersions, bedrock, java, paper, pocketmine, powernukkit, spigot } from "./index";
+
+const rootVersions = path.join(process.cwd(), "versions");
+const Bedrock = path.join(rootVersions, "bedrock");
+const Pocketmine = path.join(rootVersions, "pocketmine");
+const Powernukkit = path.join(rootVersions, "powernukkit");
+const Java = path.join(rootVersions, "java");
+const Spigot = path.join(rootVersions, "spigot");
+const Paper = path.join(rootVersions, "paper");
+
+(async function(){
+  if (!fsOld.existsSync(rootVersions)) await fs.mkdir(rootVersions, {recursive: true});
+  if (!fsOld.existsSync(Bedrock)) await fs.mkdir(Bedrock, {recursive: true});
+  if (!fsOld.existsSync(Pocketmine)) await fs.mkdir(Pocketmine, {recursive: true});
+  if (!fsOld.existsSync(Powernukkit)) await fs.mkdir(Powernukkit, {recursive: true});
+  if (!fsOld.existsSync(Java)) await fs.mkdir(Java, {recursive: true});
+  if (!fsOld.existsSync(Spigot)) await fs.mkdir(Spigot, {recursive: true});
+  if (!fsOld.existsSync(Paper)) await fs.mkdir(Paper, {recursive: true});
+
+  const bedrockData = await getVersions<bedrock[]>("bedrock", "all", true);
+  fs.writeFile(path.join(Bedrock, "latest.json"), JSON.stringify(bedrockData.find(release => release.latest), null, 2));
+  fs.writeFile(path.join(Bedrock, "all.json"), JSON.stringify(bedrockData, null, 2));
+  await Promise.all(bedrockData.map(async releases => {
+    const version = path.join(Bedrock, `${releases.version}.json`);
+    await fs.writeFile(version, JSON.stringify(releases, null, 2));
+    await fs.utimes(version, new Date(releases.date), new Date(releases.date));
+  }));
+
+  const PocketmineData = await getVersions<pocketmine[]>("pocketmine", "all", true);
+  fs.writeFile(path.join(Pocketmine, "latest.json"), JSON.stringify(PocketmineData.find(release => release.latest), null, 2));
+  fs.writeFile(path.join(Pocketmine, "all.json"), JSON.stringify(PocketmineData, null, 2));
+  await Promise.all(PocketmineData.map(async releases => {
+    const version = path.join(Pocketmine, `${releases.version}.json`);
+    await fs.writeFile(version, JSON.stringify(releases, null, 2));
+    await fs.utimes(version, new Date(releases.date), new Date(releases.date));
+  }));
+
+  const PowernukkitData = await getVersions<powernukkit[]>("powernukkit", "all", true);
+  fs.writeFile(path.join(Powernukkit, "latest.json"), JSON.stringify(PowernukkitData.find(release => release.latest), null, 2));
+  fs.writeFile(path.join(Powernukkit, "all.json"), JSON.stringify(PowernukkitData, null, 2));
+  await Promise.all(PowernukkitData.map(async releases => {
+    const version = path.join(Powernukkit, `${releases.version}.json`);
+    await fs.writeFile(version, JSON.stringify(releases, null, 2));
+    await fs.utimes(version, new Date(releases.date), new Date(releases.date));
+  }));
+
+  const JavaData = await getVersions<java[]>("java", "all", true);
+  fs.writeFile(path.join(Java, "latest.json"), JSON.stringify(JavaData.find(release => release.latest), null, 2));
+  fs.writeFile(path.join(Java, "all.json"), JSON.stringify(JavaData, null, 2));
+  await Promise.all(JavaData.map(async releases => {
+    const version = path.join(Java, `${releases.version}.json`);
+    await fs.writeFile(version, JSON.stringify(releases, null, 2));
+    await fs.utimes(version, new Date(releases.date), new Date(releases.date));
+  }));
+
+  const SpigotData = await getVersions<spigot[]>("spigot", "all", true);
+  fs.writeFile(path.join(Spigot, "latest.json"), JSON.stringify(SpigotData.find(release => release.latest), null, 2));
+  fs.writeFile(path.join(Spigot, "all.json"), JSON.stringify(SpigotData, null, 2));
+  await Promise.all(SpigotData.map(async releases => {
+    const version = path.join(Spigot, `${releases.version}.json`);
+    await fs.writeFile(version, JSON.stringify(releases, null, 2));
+    await fs.utimes(version, new Date(releases.date), new Date(releases.date));
+  }));
+
+  const PaperData = await getVersions<paper[]>("paper", "all", true);
+  fs.writeFile(path.join(Paper, "latest.json"), JSON.stringify(PaperData.find(release => release.latest), null, 2));
+  fs.writeFile(path.join(Paper, "all.json"), JSON.stringify(PaperData, null, 2));
+  await Promise.all(PaperData.map(async releases => {
+    const version = path.join(Paper, `${releases.version}_${releases.build}.json`);
+    await fs.writeFile(version, JSON.stringify(releases, null, 2));
+    await fs.utimes(version, new Date(releases.date), new Date(releases.date));
+  }));
+})();

src/exports.ts

@@ -5,7 +5,6 @@ import type { paperSchema } from "./db/paper";
 import type { powernukkitSchema } from "./db/powernukkit";
 import type { pocketminemmpSchema } from "./db/pocketmine";
 import type { spigotSchema } from "./db/spigot";
-const versionURLs = ["https://mcpeversion-static.sirherobrine23.org/", "https://mcpeversions.sirherobrine23.org", "https://mcpeversions_backup.sirherobrine23.org"];
 
 export type BdsCorePlatforms = "bedrock"|"java"|"paper"|"powernukkit"|"pocketmine"|"spigot";
 export type all = bedrockSchema|javaSchema|powernukkitSchema|paperSchema|pocketminemmpSchema|spigotSchema
@@ -20,16 +19,19 @@ export type {
 
 export async function findVersion<PlatformSchema = all[]>(bdsPlaform: BdsCorePlatforms): Promise<PlatformSchema>;
 export async function findVersion<PlatformSchema = all>(bdsPlaform: BdsCorePlatforms, version: string|boolean): Promise<PlatformSchema>;
-export async function findVersion<PlatformSchema = all|all[]>(bdsPlaform: BdsCorePlatforms, version?: string|boolean): Promise<PlatformSchema> {
-  for (let url of versionURLs) {
+export async function findVersion<PlatformSchema = all>(bdsPlaform: BdsCorePlatforms, version: string|boolean, ignoreStatic: boolean): Promise<PlatformSchema>;
+export async function findVersion<PlatformSchema = all|all[]>(bdsPlaform: BdsCorePlatforms, version?: string|boolean, ignoreStatic?: boolean): Promise<PlatformSchema> {
+  const versionURLs = ["https://mcpeversions_backup.sirherobrine23.org", "https://mcpeversions.sirherobrine23.org"];
+  if (!ignoreStatic) versionURLs.push("https://mcpeversion-static.sirherobrine23.org/"); else console.warn("Using dynamic APIs, some may be down!");
+  for (let url of versionURLs.reverse()) {
     url += "/"+bdsPlaform;
     if (/static/.test(url)) {
       if (version === undefined) url += "/all.json";
       else if (typeof version === "boolean") url += "/latest.json";
       else url += `/${version}.json`;
-
     } else {
-      if (typeof version !== "undefined") {
+      if (version === undefined||version === "all") url += "/";
+      else {
         if (typeof version === "boolean"||version === "latest") url += "/latest";
         else url += `/search?version=${version}`;
       }
@@ -46,51 +48,29 @@ export async function findVersion<PlatformSchema = all|all[]>(bdsPlaform: BdsCor
 export const platformManeger = {
   bedrock: {
     async all(){return findVersion<bedrockSchema[]>("bedrock");},
-    async find(version: string|boolean){return findVersion<bedrockSchema>("bedrock", version);},
-    async getBedrockZip(version: string|boolean, options: {platform?: NodeJS.Platform}) {
-      return platformManeger.bedrock.find(version).then(res => {
-        const plaftorm = options?.platform||process.platform;
-        if (res.url[plaftorm] === undefined) throw new Error("Platform not avaible");
-        return httpRequests.fetchBuffer(res.url[plaftorm]);
-      });
-    }
+    async find(version: string|boolean){return findVersion<bedrockSchema>("bedrock", version);}
   },
   pocketmine: {
     async all(){return findVersion<pocketminemmpSchema[]>("pocketmine");},
-    async find(version: string|boolean){return findVersion<pocketminemmpSchema>("pocketmine", version);},
-    async getPhar(version: string|boolean){
-      return platformManeger.pocketmine.find(version).then(res => httpRequests.fetchBuffer(res.url));
-    },
-    async getPhp(query?: {os?: string, arch?: string}){
-      let os = RegExp(query?.os||"(win32|windows|linux|macos|mac)");
-      let arch = RegExp(query?.arch||".*");
-      const rele = await httpRequests.GithubRelease("The-Bds-Maneger/Build-PHP-Bins");
-      for (const release of rele) {
-        for (const asset of release.assets) {
-          if (os.test(asset.name) && arch.test(asset.name)) return {buffer: await httpRequests.fetchBuffer(asset.browser_download_url), name: asset.name};
-        }
-      }
-      throw new Error("No bin found");
-    }
+    async find(version: string|boolean){return findVersion<pocketminemmpSchema>("pocketmine", version);}
   },
   powernukkit: {
     async all(){return findVersion<powernukkitSchema[]>("powernukkit");},
-    async find(version: string|boolean){return findVersion<powernukkitSchema>("powernukkit", version);},
-    async getJar(version: string|boolean){return platformManeger.powernukkit.find(version).then(res => httpRequests.fetchBuffer(res.url))}
+    async find(version: string|boolean){return findVersion<powernukkitSchema>("powernukkit", version);}
   },
   java: {
     async all(){return findVersion<javaSchema[]>("java");},
-    async find(version: string|boolean){return findVersion<javaSchema>("java", version);},
-    async getJar(version: string|boolean){return platformManeger.java.find(version).then(res => httpRequests.fetchBuffer(res.url))}
+    async find(version: string|boolean){return findVersion<javaSchema>("java", version);}
   },
   spigot: {
     async all(){return findVersion<spigotSchema[]>("spigot");},
-    async find(version: string|boolean){return findVersion<spigotSchema>("spigot", version);},
-    async getJar(version: string|boolean){return platformManeger.spigot.find(version).then(res => httpRequests.fetchBuffer(res.url))}
+    async find(version: string|boolean){return findVersion<spigotSchema>("spigot", version);}
   },
   paper: {
     async all(){return findVersion<paperSchema[]>("paper");},
-    async find(version: string|boolean){return findVersion<paperSchema>("paper", version);},
-    async getJar(version: string|boolean){return platformManeger.paper.find(version).then(res => httpRequests.fetchBuffer(res.url))}
+    async find(version: string|boolean, build?: number|string){
+      if (!build) build = (await findVersion<paperSchema[]>("paper")).find(ver => ver.version === version)?.build;
+      return findVersion<paperSchema>("paper", `${version}${!!build?"_"+build:""}`);
+    }
   }
 };