@intelligentgraphics/ig.gfx.packager 2.3.3 → 3.0.0-alpha.0

package/build/commands/release.js

@@ -0,0 +1,576 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var promises = require('stream/promises');
+var require$$1 = require('child_process');
+var cli = require('../cli.js');
+var index = require('./build.js');
+var versionFile = require('../versionFile.js');
+var axios = require('axios');
+var Ajv = require('ajv');
+var JSZip = require('jszip');
+var terser = require('terser');
+var dependencies = require('../dependencies.js');
+require('update-notifier');
+require('yargs');
+require('tslib');
+require('os');
+require('assert');
+require('events');
+require('buffer');
+require('stream');
+require('util');
+require('constants');
+require('write-pkg');
+require('inquirer');
+require('glob');
+require('typescript');
+require('../scripts.js');
+require('typedoc');
+require('simple-git');
+require('resolve');
+
+function _interopNamespaceDefault(e) {
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n.default = e;
+	return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var terser__namespace = /*#__PURE__*/_interopNamespaceDefault(terser);
+
+const PLUGIN_ID = "0feba3a0-b6d1-11e6-9598-0800200c9a66";
+/**
+ * Starts an asset service session and returns the sessionId
+ *
+ * @param {SessionStartParams} params
+ * @returns
+ */
+const startSession = async ({
+  url,
+  authentication,
+  ...params
+}) => {
+  const payload = {
+    ...params,
+    user: undefined,
+    password: undefined,
+    license: undefined,
+    plugin: PLUGIN_ID
+  };
+  if (authentication.type === "credentials") {
+    payload.user = authentication.username;
+    payload.password = authentication.password;
+  } else if (authentication.type === "license") {
+    payload.license = authentication.license;
+  }
+  const {
+    data: {
+      session: sessionId,
+      state
+    }
+  } = await axios.post(`Session/Start2`, JSON.stringify(payload), {
+    baseURL: url
+  });
+  if (state !== "SUCCESS") {
+    throw new Error(`Could not start session: Asset server responded with ${state}`);
+  }
+  return {
+    url,
+    sessionId,
+    domain: params.domain,
+    subDomain: params.subDomain
+  };
+};
+const closeSession = async session => {
+  await axios.get(`Session/Close/${session.sessionId}`, {
+    baseURL: session.url
+  });
+};
+const uploadPackage = async (session, {
+  name,
+  version
+}, zipFilePath) => {
+  try {
+    await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}`, zipFilePath);
+  } catch (err) {
+    await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}/`, zipFilePath);
+  }
+};
+const getExistingPackages = async session => axios.get(`Script/GetInformation/${session.sessionId}`, {
+  baseURL: session.url,
+  validateStatus: status => status === 404 || status === 200
+}).then(({
+  data
+}) => Array.isArray(data) ? data : undefined);
+const uploadPackageToUrl = (url, path, zipFilePath) => axios.post(path, fs__namespace.createReadStream(zipFilePath), {
+  baseURL: url
+}).then(({
+  data,
+  status
+}) => {
+  let objectBody;
+  if (typeof data === "string") {
+    try {
+      objectBody = JSON.parse(data);
+    } catch (err) {}
+  } else if (typeof data === "object") {
+    objectBody = data;
+  }
+  if (objectBody !== undefined) {
+    if ("state" in objectBody && objectBody.state !== "SUCCESS") {
+      throw new Error(objectBody.response ?? objectBody.state);
+    }
+  }
+  if (status >= 400) {
+    if (objectBody !== undefined) {
+      let text = "";
+      for (const key in objectBody) {
+        text += key + ": \n";
+        if (typeof objectBody[key] === "object") {
+          text += JSON.stringify(objectBody[key], undefined, 2);
+        } else {
+          text += objectBody[key];
+        }
+        text += "\n\n";
+      }
+      throw new Error(text);
+    }
+    throw new Error(data);
+  }
+  return data;
+});
+
+const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage) => {
+  const archive = new JSZip();
+  archive.file("_Package.json", JSON.stringify(creatorPackage, null, 2));
+  const index = dependencies.readPublishedPackageCreatorIndex(location);
+  if (index !== undefined) {
+    archive.file("_Index.json", JSON.stringify(index, null, 2));
+  }
+  archive.file(manifest.main, fs__namespace.createReadStream(path__namespace.join(location.path, manifest.main)));
+  return archive;
+};
+let validateSchema;
+const runtimeScripts = ["Interactor", "Core", "Mixed"];
+const notRuntimeScripts = ["Context", "Evaluator"];
+const buildArchiveFromPackage = async (workspaceLocation, packageLocation, data) => {
+  const {
+    domain,
+    subdomain
+  } = cli.parseCreatorPackageName(data);
+  const logStep = step => index.logPackageMessage(data.Package, step);
+  if (validateSchema === undefined) {
+    validateSchema = await axios.get("https://archive.intelligentgraphics.biz/schemas/gfx/animation.json").then(({
+      data
+    }) => new Ajv({
+      coerceTypes: true,
+      allErrors: true,
+      removeAdditional: true,
+      useDefaults: "empty",
+      validateSchema: "log"
+    }).compile(data));
+  }
+  const libFilePath = path__namespace.join(cli.getWorkspaceOutputPath(workspaceLocation), `${data.Package}.min.js`);
+  const scriptDirectories = [packageLocation.path, packageLocation.scriptsDir];
+  if (subdomain === "GFX.Standard") {
+    logStep(`Including Images folder`);
+    scriptDirectories.push(path__namespace.join(packageLocation.path, "Images"));
+  }
+  const manifest = cli.readPackageCreatorManifest(packageLocation);
+  if (manifest !== undefined) {
+    if (manifest.RunTime && notRuntimeScripts.includes(manifest.Type)) {
+      logStep("Setting script RunTime to false because of script type");
+      cli.writePackageCreatorManifest(packageLocation, {
+        ...manifest,
+        RunTime: false
+      });
+    } else if (!manifest.RunTime && runtimeScripts.includes(manifest.Type)) {
+      logStep("Setting script RunTime to true because of script type");
+      cli.writePackageCreatorManifest(packageLocation, {
+        ...manifest,
+        RunTime: true
+      });
+    }
+  }
+
+  // if (index === undefined) {
+  // 	throw new Error(
+  // 		`Could not find an "${INDEX_FILE}" file in "${primaryScriptDir}"`,
+  // 	);
+  // }
+
+  const animations = new Map();
+  for (const scriptFilePath of cli.readPackageAnimationList(packageLocation)) {
+    const content = fs__namespace.readFileSync(scriptFilePath, {
+      encoding: "utf8"
+    });
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (err) {
+      const relativePath = path__namespace.relative(workspaceLocation.path, scriptFilePath);
+      if (err instanceof SyntaxError) {
+        throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
+      }
+      throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
+        cause: err
+      });
+    }
+    validateSchema(data);
+    animations.set(data.Id, JSON.stringify(data));
+  }
+  let libFile;
+  try {
+    libFile = fs__namespace.readFileSync(libFilePath, {
+      encoding: "utf8"
+    });
+  } catch (err) {
+    if (!cli.isErrorENOENT(err)) {
+      throw err;
+    }
+  }
+  if (libFile === undefined) {
+    if (animations.size === 0) {
+      throw new Error(`Could not find a javascript file at "${libFilePath}".
+Packaging without a javascript file is only allowed when animation json files are available`);
+    }
+  }
+  const archive = new JSZip();
+  let library = "";
+  if (libFile) {
+    library = libFile;
+  }
+  if (!library) {
+    const date = new Date(Date.now());
+    library = `/* This file is part of the ${domain} Data Packages.
+		* Copyright (C) ${date.getFullYear()} intelligentgraphics. All Rights Reserved. */`;
+  }
+  if (animations.size > 0) {
+    const scopeParts = data.Scope.split(".");
+    const scope = data.Scope;
+    library += createNamespace(scopeParts);
+    for (const [name, data] of animations) {
+      library += `${scope}.${name} = ` + data + ";";
+      console.log(`${name}: Added animation ${scope}.${name}`);
+    }
+  }
+  const minifyResult = terser__namespace.minify(library, {
+    ecma: 5
+  });
+  archive.file(`${data.Package}.js`, minifyResult.code);
+  archive.file(`_Package.json`, JSON.stringify(data, null, 2));
+  const creatorIndex = cli.readPackageCreatorIndex(packageLocation);
+  if (creatorIndex !== undefined) {
+    archive.file(`_Index.json`, JSON.stringify(creatorIndex, null, 2));
+  }
+  for (const directory of scriptDirectories) {
+    try {
+      for (const file of fs__namespace.readdirSync(directory)) {
+        const {
+          ext
+        } = path__namespace.parse(file);
+        switch (ext) {
+          case ".png":
+          case ".jpeg":
+          case ".jpg":
+            break;
+          default:
+            continue;
+        }
+        archive.file(file, fs__namespace.createReadStream(path__namespace.join(directory, file)));
+      }
+    } catch (err) {
+      console.error(`Script directory "${directory}" does not exist`);
+    }
+  }
+  return archive;
+};
+const createNamespace = parts => {
+  let code = `var ${parts[0]};`;
+  for (let index = 0; index < parts.length; index++) {
+    const path = parts.slice(0, index + 1).join(".");
+    code += `\n(${path} = ${path} || {});`;
+  }
+  return code;
+};
+
+const releaseFolder = async options => {
+  const workspace = cli.detectWorkspace(options.cwd);
+  const location = cli.detectPackage(workspace, options.directory);
+  const {
+    write: writeVersionFile,
+    reset: resetVersionFile
+  } = versionFile.getVersionFileHandler(location);
+  const packageDescription = cli.readPackageCreatorManifest(location);
+  const fullPackageName = packageDescription.Package;
+  const {
+    domain,
+    subdomain
+  } = cli.parseCreatorPackageName(packageDescription);
+  const publishDomain = options.domain ?? domain;
+  const publishSubdomain = options.subdomain ?? subdomain;
+  const sharedPackageJson = cli.readWorkspaceNpmManifest(workspace);
+  let newVersion;
+  try {
+    newVersion = versionFile.parseVersionFromString(options.newVersion);
+  } catch (err) {
+    throw new Error(`Please enter a version in this format 1.0.0.100`);
+  }
+  if (newVersion.buildNumber < 100) {
+    newVersion.preRelease = {
+      type: "beta",
+      version: newVersion.buildNumber
+    };
+  } else if (newVersion.buildNumber > 100) {
+    newVersion.preRelease = {
+      type: "patch",
+      version: newVersion.buildNumber - 100
+    };
+  }
+  if (sharedPackageJson !== undefined) {
+    index.logPackageMessage(packageDescription.Package, `Running npm install to make sure all dependencies are up to date`);
+    require$$1.execSync(`npm install`, {
+      encoding: "utf-8",
+      cwd: workspace.path
+    });
+  }
+  const binDir = cli.getWorkspaceOutputPath(workspace);
+  fs__namespace.mkdirSync(binDir, {
+    recursive: true
+  });
+  let assetServerPackageDetails;
+  let packageNameWithVersion;
+  {
+    const versionWithoutPrelease = newVersion.clone();
+    versionWithoutPrelease.preRelease = undefined;
+    const newVersionString = versionWithoutPrelease.toVersionString({
+      buildNumber: true
+    });
+    packageNameWithVersion = `${packageDescription.Package}_${newVersionString}`;
+    assetServerPackageDetails = {
+      name: packageDescription.Package,
+      version: newVersionString
+    };
+  }
+  const zipFilePath = path__namespace.join(binDir, packageNameWithVersion + ".zip");
+  try {
+    if (options.pushOnly) {
+      if (!fs__namespace.existsSync(zipFilePath)) {
+        throw new Error(`Expected a zip file to exist at path ${zipFilePath} since pushOnly is specified`);
+      }
+    } else {
+      const gitVersionInformation = await versionFile.getVersionInformationFromGit(workspace, location);
+      writeVersionFile(fullPackageName, newVersion);
+      const bannerText = sharedPackageJson !== undefined ? versionFile.getWorkspaceBannerText(sharedPackageJson) : undefined;
+      await index.buildFolders({
+        ...options,
+        directories: [location.path],
+        skipPackagesWithoutTsFiles: true,
+        banner: options.banner ? {
+          text: bannerText,
+          commit: gitVersionInformation.commit,
+          commitDirty: gitVersionInformation.dirty,
+          version: newVersion.toVersionString({
+            buildNumber: true
+          }),
+          date: new Date(Date.now())
+          //  gitVersionInformation.commitDate
+          // 	? new Date(gitVersionInformation.commitDate)
+          // 	: new Date(Date.now()),
+        } : undefined
+      });
+      newVersion.preRelease = undefined;
+      try {
+        fs__namespace.rmSync(zipFilePath);
+      } catch (err) {
+        if (!cli.isErrorENOENT(err)) {
+          throw err;
+        }
+      }
+      const archive = await buildArchiveFromPackage(workspace, location, packageDescription);
+      const zipOutputStream = fs__namespace.createWriteStream(zipFilePath);
+      await promises.pipeline(archive.generateNodeStream(), zipOutputStream);
+    }
+    if (!options.noUpload) {
+      if (!options.authentication) {
+        throw new Error(`Expected authentication to be available`);
+      }
+      index.logPackageMessage(packageDescription.Package, `Opening connection to asset server`);
+      const sessionManager = await createSessionManager({
+        url: options.service,
+        address: options.address,
+        domain: publishDomain,
+        subDomain: publishSubdomain,
+        authentication: options.authentication
+      });
+      index.logPackageMessage(packageDescription.Package, `Making sure all dependencies are available with an acceptable version`);
+      if (!(await ensureRequiredVersions(workspace, packageDescription, sessionManager, options.prompter))) {
+        index.logPackageMessage(packageDescription.Package, "AssetService does not yet support required apis for dependency check");
+      }
+      index.logPackageMessage(packageDescription.Package, `Uploading package to ${publishDomain}.${publishSubdomain}`);
+      await uploadPackage(sessionManager.getTargetSession(), assetServerPackageDetails, zipFilePath);
+      await sessionManager.destroy().catch(err => {
+        index.logPackageMessage(packageDescription.Package, `Failed to close asset service session(s): ${err}`);
+      });
+    }
+  } catch (err) {
+    resetVersionFile();
+    throw err;
+  }
+  if (newVersion.buildNumber >= 100 && !options.pushOnly) {
+    index.logPackageMessage(fullPackageName, cli.translate("messages.movingReleaseZip"));
+    const zipFileName = `${packageNameWithVersion}.zip`;
+    const releasesPath = cli.getPackageReleasesDirectory(location);
+    fs__namespace.mkdirSync(releasesPath, {
+      recursive: true
+    });
+    fs__namespace.copyFileSync(zipFilePath, path__namespace.join(releasesPath, zipFileName));
+  }
+};
+const ensureRequiredVersions = async (workspaceLocation, creatorPackage, sessionManager, prompter) => {
+  const targetSession = sessionManager.getTargetSession();
+  const rawUploadedPackages = await getExistingPackages(targetSession);
+  if (rawUploadedPackages === undefined) {
+    return false;
+  }
+  const uploadedPackages = rawUploadedPackages.map(entry => {
+    let version;
+    try {
+      version = versionFile.parseVersionFromString(entry.informalVersion);
+    } catch (err) {
+      throw new Error(`Encountered invalid format for version ${entry.informalVersion}`);
+    }
+    if (version.buildNumber < 100) {
+      version.preRelease = {
+        type: "beta",
+        version: version.buildNumber
+      };
+    } else if (version.buildNumber > 100) {
+      version.preRelease = {
+        type: "patch",
+        version: version.buildNumber - 100
+      };
+    }
+    return {
+      ...entry,
+      version
+    };
+  });
+  const libraries = dependencies.determineWorkspaceIGLibraries(workspaceLocation);
+  for (const libraryLocation of libraries) {
+    const libraryManifest = dependencies.readPublishedPackageNpmManifest(libraryLocation);
+    const libraryCreatorPackage = dependencies.readPublishedPackageCreatorManifest(libraryLocation);
+    if (libraryCreatorPackage === undefined || libraryManifest.main === undefined || libraryCreatorPackage.Package === creatorPackage.Package) {
+      continue;
+    }
+    const libraryVersion = cli.build.PackageVersion.extractFromLine(libraryManifest.version);
+    if (libraryVersion.preRelease) {
+      libraryVersion.buildNumber = libraryVersion.preRelease.version;
+      libraryVersion.preRelease = undefined;
+    } else {
+      libraryVersion.buildNumber = 100;
+    }
+    let uploadedPackageInBasics;
+    let uploadedPackageInTarget;
+    for (const uploadedPackage of uploadedPackages) {
+      if (uploadedPackage.scope === libraryCreatorPackage.Package) {
+        if (uploadedPackage.support) {
+          uploadedPackageInBasics = uploadedPackage;
+        } else {
+          uploadedPackageInTarget = uploadedPackage;
+        }
+      }
+    }
+    if (targetSession.subDomain !== "Basics" && (uploadedPackageInBasics !== undefined || uploadedPackageInTarget !== undefined)) {
+      index.logPackageMessage(creatorPackage.Package, `Package ${libraryCreatorPackage.Package} is uploaded both for Basics and ${targetSession.subDomain}. The package within ${targetSession.subDomain} will be used.`);
+    }
+    const validInBasics = uploadedPackageInBasics !== undefined && !uploadedPackageInBasics.version.isLesserThan(libraryVersion);
+    const validInTarget = uploadedPackageInTarget !== undefined && !uploadedPackageInTarget.version.isLesserThan(libraryVersion);
+    if (validInBasics || validInTarget) {
+      index.logPackageMessage(creatorPackage.Package, `Skipping upload for package ${libraryCreatorPackage.Package} as it is already uploaded and up to date.`);
+      continue;
+    }
+    if (uploadedPackageInBasics) {
+      index.logPackageMessage(creatorPackage.Package, `Found invalid version for package ${libraryCreatorPackage.Package} in Basics.`);
+    }
+    if (targetSession.subDomain !== "Basics" && uploadedPackageInTarget) {
+      index.logPackageMessage(creatorPackage.Package, `Found invalid version for package ${libraryCreatorPackage.Package} in ${targetSession.subDomain}.`);
+    }
+    const possibleTargets = ["Basics"];
+    if (targetSession.subDomain !== "Basics") {
+      possibleTargets.push(targetSession.subDomain);
+    }
+    const uploadTargetScope = await prompter.ask({
+      message: `${libraryCreatorPackage.Package} is not available at all or has an invalid version. Select the scope to upload it to`,
+      options: [...possibleTargets, "Skip"],
+      default: possibleTargets[0]
+    });
+    if (uploadTargetScope === "Skip") {
+      continue;
+    }
+    const archive = buildArchiveFromPublishedPackage(libraryLocation, libraryManifest, libraryCreatorPackage);
+    const newVersionString = libraryVersion.toVersionString({
+      buildNumber: true
+    });
+    const packageNameWithVersion = `${libraryCreatorPackage.Package}_${newVersionString}`;
+    const zipFilePath = path__namespace.join(cli.getWorkspaceOutputPath(workspaceLocation), `${packageNameWithVersion}.zip`);
+    try {
+      fs__namespace.rmSync(zipFilePath);
+    } catch (err) {
+      if (!cli.isErrorENOENT(err)) {
+        throw err;
+      }
+    }
+    const zipOutputStream = fs__namespace.createWriteStream(zipFilePath);
+    await promises.pipeline(archive.generateNodeStream(), zipOutputStream);
+    const session = uploadTargetScope === "Basics" ? await sessionManager.getBasicsSession() : targetSession;
+    index.logPackageMessage(creatorPackage.Package, `Uploading package ${libraryCreatorPackage.Package} with version ${newVersionString} to ${session.domain}.${session.subDomain}`);
+    await uploadPackage(session, {
+      name: libraryCreatorPackage.Package,
+      version: newVersionString
+    }, zipFilePath);
+  }
+  return true;
+};
+const createSessionManager = async params => {
+  const targetSession = await startSession(params);
+  let basicsSession;
+  return {
+    getBasicsSession: async () => {
+      if (targetSession.subDomain === "Basics") {
+        return targetSession;
+      }
+      if (basicsSession === undefined) {
+        basicsSession = await startSession({
+          ...params,
+          subDomain: "Basics"
+        });
+      }
+      return basicsSession;
+    },
+    getTargetSession: () => targetSession,
+    destroy: async () => {
+      await closeSession(targetSession);
+      if (basicsSession !== undefined) {
+        await closeSession(basicsSession);
+      }
+    }
+  };
+};
+
+exports.releaseFolder = releaseFolder;
+//# sourceMappingURL=release.js.map