occam-server 2.0.1 → 7.0.5

package/package.json

@@ -1,35 +1,33 @@
 {
   "name": "occam-server",
   "author": "James Smith",
-  "version": "2.0.1",
-  "license": "MIT",
-  "homepage": "https://github.com/jecs-imperial/occam-server",
-  "description": "Occam's server portion.",
+  "version": "7.0.5",
+  "license": "MIT, Anti-996",
+  "homepage": "https://github.com/djalbat/occam-server",
+  "description": "Occam's server side functionality.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jecs-imperial/occam-server"
+    "url": "https://github.com/djalbat/occam-server"
   },
   "dependencies": {
-    "body-parser": "^1.18.3",
-    "express": "^4.16.4",
-    "necessary": "^3.4.0",
-    "occam-file-system": "^2.0.1",
-    "occam-open-cli": "^1.5.34"
+    "necessary": "^17.0.9",
+    "occam-model": "^1.0.495"
   },
   "devDependencies": {
-    "chai": "~2.2.0",
-    "babel": "^6.5.2",
-    "babel-cli": "^6.7.5",
-    "babel-preset-es2015": "^6.6.0",
-    "chokidar-cli": "^1.2.0"
+    "@swc/core": "1.13.20",
+    "watchful-cli": "^1.7.67"
   },
   "scripts": {
     "clean": "rm -rf ./lib",
-    "babel": "babel ./es6 --presets=es2015 --out-dir=./lib",
-    "babel-debug": "babel ./es6 --presets=es2015 --source-maps inline --out-dir=./lib",
-    "build": "npm run clean && npm run babel",
-    "build-debug": "npm run clean && npm run babel-debug",
-    "watch": "npm run build && chokidar 'index.js' './es6/**/*.js' -c 'npm run build'",
-    "watch-debug": "npm run build-debug && chokidar 'index.js' './es6/**/*.js' -c 'npm run build-debug'"
-  }
+    "watchful": "watchful -m --transpiler=swc --source-directory=./src --lib-directory=./lib",
+    "batch": "npm run watchful batch --",
+    "batch-debug": "npm run watchful batch -- --debug",
+    "incremental": "npm run watchful incremental --",
+    "incremental-debug": "npm run watchful incremental -- --debug",
+    "build": "npm run clean && npm run batch",
+    "build-debug": "npm run clean && npm run batch-debug",
+    "watch": "npm run clean && npm run batch && npm run incremental",
+    "watch-debug": "npm run clean && npm run batch-debug && npm run incremental-debug"
+  },
+  "main": "./lib/index.js"
 }

package/src/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const END = "end";
+export const DATA = "data";
+export const EMPTY_STRING = "";

package/src/createProjectEntries.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { nullifyTargetEntryPath } from "./utilities/pathMap";
+import { pathUtilities, fileSystemUtilities } from "necessary";
+
+const { concatenatePaths } = pathUtilities,
+      { createFile, createDirectory, checkEntryExists: checkFileExists, checkEntryExists: checkDirectoryExists } = fileSystemUtilities;
+
+export default function createProjectEntries(projectsDirectoryPath, json, callback) {
+  const { pathMaps } = json;
+
+  pathMaps.forEach((pathMap) => {
+    createProjectEntry(projectsDirectoryPath, pathMap);
+  });
+
+  json = {
+    pathMaps
+  };
+
+  callback(json);
+}
+
+export function createProjectEntry(projectsDirectoryPath, pathMap) {
+  const { entryDirectory } = pathMap;
+
+  entryDirectory ?
+    createProjectDirectory(projectsDirectoryPath, pathMap) :
+      createProjectFile(projectsDirectoryPath, pathMap);
+}
+
+function createProjectFile(projectsDirectoryPath, pathMap) {
+  const { targetEntryPath } = pathMap,
+        targetFilePath = targetEntryPath, ///
+        absoluteTargetFilePath = concatenatePaths(projectsDirectoryPath, targetFilePath),
+        targetFileExists = checkFileExists(absoluteTargetFilePath);
+
+  if (targetFileExists) {
+    nullifyTargetEntryPath(pathMap);
+
+    return;
+  }
+
+  try {
+    const filePath = absoluteTargetFilePath;  ///
+
+    createFile(filePath);
+  } catch (error) {
+    nullifyTargetEntryPath(pathMap);
+  }
+}
+
+function createProjectDirectory(projectsDirectoryPath, pathMap) {
+  const { targetEntryPath } = pathMap,
+        targetDirectoryPath = targetEntryPath, ///
+        absoluteTargetDirectoryPath = concatenatePaths(projectsDirectoryPath, targetDirectoryPath),
+        targetDirectoryExists = checkDirectoryExists(absoluteTargetDirectoryPath);
+
+  if (targetDirectoryExists) {
+    nullifyTargetEntryPath(pathMap);
+
+    return;
+  }
+
+  try {
+    const directoryPath = absoluteTargetDirectoryPath;  ///
+
+    createDirectory(directoryPath);
+  } catch (error) {
+    nullifyTargetEntryPath(pathMap);
+  }
+}

package/src/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+export { default as loadFile } from "./loadFile";
+export { default as saveFile } from "./saveFile";
+export { default as loadFiles } from "./loadFiles";
+export { default as loadProject } from "./loadProject";
+export { default as loadRelease } from "./loadRelease";
+export { default as loadProjects } from "./loadProjects";
+export { default as loadReleases } from "./loadReleases";
+export { default as removeRelease } from "./removeRelease";
+export { default as httpUtilities } from "./utilities/http";
+export { default as moveProjectEntries } from "./moveProjectEntries";
+export { default as fileSystemUtilities } from "./utilities/fileSystem";
+export { default as removeProjectEntries } from "./removeProjectEntries";
+export { default as renameProjectEntries } from "./renameProjectEntries";
+export { default as createProjectEntries } from "./createProjectEntries";

package/src/loadFile.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { loadFile as loadFileEx } from "./utilities/fileSystem"
+
+export default function loadFile(projectsDirectoryPath, json, callback) {
+  const { filePath } = json,
+        path = filePath,  ///
+        file = loadFileEx(path, projectsDirectoryPath);
+
+  json = (file !== null) ?  ///
+            file.toJSON():
+              null;
+
+  return callback(json);
+}

package/src/loadFiles.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { loadFiles as loadFilesEx } from "./utilities/fileSystem"
+
+export default function loadFiles(projectsDirectoryPath, json, callback) {
+  const { filePaths } = json,
+        paths = filePaths, ///
+        files = loadFilesEx(paths, projectsDirectoryPath);
+
+  json = (files !== null) ? ///
+            files.toJSON() :
+              null;
+
+  return callback(json);
+}

package/src/loadProject.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { loadProject as loadProjectEx } from "./utilities/fileSystem"
+
+export default function loadProject(projectsDirectoryPath, json, callback) {
+  const { projectName } = json,
+        loadOnlyRecognisedFiles = false, ///
+        project = loadProjectEx(projectName, projectsDirectoryPath, loadOnlyRecognisedFiles);
+
+  json = (project !== null) ?  ///
+            project.toJSON():
+              null;
+
+  return callback(json);
+}

package/src/loadProjects.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { loadProjects as loadProjectsEx } from "./utilities/fileSystem";
+
+export default function loadProjects(projectsDirectoryPath, json, callback) {
+  const loadOnlyRecognisedFiles = false, ///
+        projects = loadProjectsEx(projectsDirectoryPath, loadOnlyRecognisedFiles);
+
+  json = (projects !== null) ?  ///
+            projects.toJSON():
+              null;
+
+  callback(json);
+}

package/src/loadRelease.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { loadRelease as loadReleaseEx } from "./utilities/fileSystem"
+
+export default function loadRelease(projectsDirectoryPath, json, callback) {
+  const { releaseName } = json,
+        release = loadReleaseEx(releaseName, projectsDirectoryPath);
+
+  json = (release !== null) ?  ///
+            release.toJSON():
+              null;
+
+  return callback(json);
+}

package/src/loadReleases.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { loadReleases as loadReleasesEx } from "./utilities/fileSystem";
+
+export default function loadReleases(projectsDirectoryPath, json, callback) {
+  const releases = loadReleasesEx(projectsDirectoryPath);
+
+  json = (releases !== null) ?  ///
+            releases.toJSON():
+              null;
+
+  callback(json);
+}

package/src/moveProjectEntries.js

@@ -0,0 +1,102 @@
+"use strict";
+
+import { pathUtilities, fileSystemUtilities } from "necessary";
+
+import { removeProjectEntry } from "./removeProjectEntries";
+import { nullifyEntryPaths, nullifyTargetEntryPath } from "./utilities/pathMap";
+
+const { concatenatePaths } = pathUtilities,
+      { moveEntry, isDirectoryEmpty, checkEntryExists, checkEntryExists: checkFileExists, checkEntryExists: checkDirectoryExists } = fileSystemUtilities;
+
+export default function moveProjectEntries(projectsDirectoryPath, json, callback) {
+  const { pathMaps } = json;
+
+  pathMaps.forEach((pathMap) => {
+    moveProjectEntry(projectsDirectoryPath, pathMap);
+  });
+
+  json = {
+    pathMaps
+  };
+
+  callback(json);
+}
+
+export function moveProjectEntry(projectsDirectoryPath, pathMap) {
+  const { targetEntryPath } = pathMap;
+
+  if (targetEntryPath === null) {
+    return;
+  }
+
+  const { sourceEntryPath } = pathMap,
+        absoluteSourceEntryPath = concatenatePaths(projectsDirectoryPath, sourceEntryPath),
+        sourceEntryExists = checkEntryExists(absoluteSourceEntryPath);
+
+  if (!sourceEntryExists) {
+    nullifyTargetEntryPath(pathMap);
+
+    return;
+  }
+
+  const { entryDirectory } = pathMap;
+
+  entryDirectory ?
+    moveProjectDirectory(projectsDirectoryPath, pathMap) :
+      moveProjectFile(projectsDirectoryPath, pathMap);
+}
+
+function moveProjectFile(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath, targetEntryPath } = pathMap,
+        sourceFilePath = sourceEntryPath, ///
+        targetFilePath = targetEntryPath, ///
+        absoluteSourceFilePath = concatenatePaths(projectsDirectoryPath, sourceFilePath),
+        absoluteTargetFilePath = concatenatePaths(projectsDirectoryPath, targetFilePath),
+        targetFileExists = checkFileExists(absoluteTargetFilePath);
+
+  if (targetFileExists) {
+    nullifyEntryPaths(pathMap);
+
+    return;
+  }
+
+  try {
+    const oldEntryPath = absoluteSourceFilePath, ///
+          newEntryPath = absoluteTargetFilePath; ///
+
+    moveEntry(oldEntryPath, newEntryPath);
+  } catch (error) {
+    nullifyEntryPaths(pathMap);
+  }
+}
+
+function moveProjectDirectory(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath, targetEntryPath } = pathMap,
+        sourceDirectoryPath = sourceEntryPath, ///
+        targetDirectoryPath = targetEntryPath, ///
+        absoluteSourceDirectoryPath = concatenatePaths(projectsDirectoryPath, sourceDirectoryPath),
+        absoluteTargetDirectoryPath = concatenatePaths(projectsDirectoryPath, targetDirectoryPath),
+        targetDirectoryExists = checkDirectoryExists(absoluteTargetDirectoryPath),
+        directoryEmpty = isDirectoryEmpty(absoluteSourceDirectoryPath);
+
+  if (!directoryEmpty) {
+    nullifyEntryPaths(pathMap);
+
+    return;
+  }
+
+  if (targetDirectoryExists) {
+    removeProjectEntry(projectsDirectoryPath, pathMap);
+
+    return;
+  }
+
+  try {
+    const oldEntryPath = absoluteSourceDirectoryPath, ///
+          newEntryPath = absoluteTargetDirectoryPath; ///
+
+    moveEntry(oldEntryPath, newEntryPath);
+  } catch (error) {
+    nullifyEntryPaths(pathMap);
+  }
+}

package/src/removeProjectEntries.js

@@ -0,0 +1,79 @@
+"use strict";
+
+import { pathUtilities, fileSystemUtilities } from "necessary";
+import { nullifyEntryPaths, nullifyTargetEntryPath } from "./utilities/pathMap";
+
+const { concatenatePaths } = pathUtilities,
+      { removeEntry, checkEntryExists, isDirectoryEmpty } = fileSystemUtilities;
+
+export default function removeProjectEntries(projectsDirectoryPath, json, callback) {
+  const { pathMaps } = json;
+
+  pathMaps.forEach((pathMap) => {
+    removeProjectEntry(projectsDirectoryPath, pathMap);
+  });
+
+  json = {
+    pathMaps
+  };
+
+  callback(json);
+}
+
+export function removeProjectEntry(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath } = pathMap;
+
+  if (sourceEntryPath === null) {
+    return;
+  }
+
+  const absoluteSourceEntryPath = concatenatePaths(projectsDirectoryPath, sourceEntryPath),
+        sourceEntryExists = checkEntryExists(absoluteSourceEntryPath);
+
+  if (!sourceEntryExists) {
+    nullifyTargetEntryPath(pathMap);
+
+    return;
+  }
+
+  const { entryDirectory } = pathMap;
+
+  entryDirectory ?
+    removeProjectDirectory(projectsDirectoryPath, pathMap) :
+      removeProjectFile(projectsDirectoryPath, pathMap);
+}
+
+function removeProjectFile(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath } = pathMap,
+        sourceFilePath = sourceEntryPath, ///
+        absoluteSourceFilePath = concatenatePaths(projectsDirectoryPath, sourceFilePath);
+
+  try {
+    const entryPath = absoluteSourceFilePath;  ///
+
+    removeEntry(entryPath);
+  } catch (error) {
+    nullifyEntryPaths(pathMap);
+  }
+}
+
+function removeProjectDirectory(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath } = pathMap,
+        sourceDirectoryPath = sourceEntryPath, ///
+        absoluteSourceDirectoryPath = concatenatePaths(projectsDirectoryPath, sourceDirectoryPath),
+        directoryEmpty = isDirectoryEmpty(absoluteSourceDirectoryPath);
+
+  if (!directoryEmpty) {
+    nullifyEntryPaths(pathMap);
+
+    return;
+  }
+
+  try {
+    const entryPath = absoluteSourceDirectoryPath;  ///
+
+    removeEntry(entryPath);
+  } catch (error) {
+    nullifyEntryPaths(pathMap);
+  }
+}

package/src/removeRelease.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { removeProjectEntry } from "./removeProjectEntries";
+
+const { last } = arrayUtilities;
+
+export default function removeRelease(projectsDirectoryPath, json, callback) {
+  let entryDirectory;
+
+  const { pathMaps } = json,
+        lastPathMap = last(pathMaps),
+        pathMap = lastPathMap;  ///
+
+  entryDirectory = false;
+
+  Object.assign(pathMap, {
+    entryDirectory
+  });
+
+  removeProjectEntry(projectsDirectoryPath, pathMap);
+
+  entryDirectory = true;
+
+  Object.assign(pathMap, {
+    entryDirectory
+  });
+
+  json = {
+    pathMaps
+  };
+
+  callback(json);
+}

package/src/renameProjectEntries.js

@@ -0,0 +1,101 @@
+"use strict";
+
+import { pathUtilities, arrayUtilities, fileSystemUtilities } from "necessary";
+
+import { nullifyEntryPaths, nullifyTargetEntryPath, nullifyTargetEntryPaths } from "./utilities/pathMap";
+
+const { last } = arrayUtilities,
+      { concatenatePaths } = pathUtilities,
+      { renameEntry, checkEntryExists, checkEntryExists: checkFileExists, checkEntryExists: checkDirectoryExists } = fileSystemUtilities;
+
+export default function renameProjectEntries(projectsDirectoryPath, json, callback) {
+  const { pathMaps } = json,
+        lastPathMap = last(pathMaps),
+        pathMap = lastPathMap; ///
+
+  renameProjectEntry(projectsDirectoryPath, pathMap);
+
+  const { targetEntryPath } = pathMap;
+
+  if (targetEntryPath === null) {
+    nullifyTargetEntryPaths(pathMaps);
+  }
+
+  json = {
+    pathMaps
+  };
+
+  callback(json);
+}
+
+export function renameProjectEntry(projectsDirectoryPath, pathMap) {
+  const { targetEntryPath } = pathMap;
+
+  if (targetEntryPath === null) {
+    return;
+  }
+
+  const { sourceEntryPath } = pathMap,
+        absoluteSourceEntryPath = concatenatePaths(projectsDirectoryPath, sourceEntryPath),
+        sourceEntryExists = checkEntryExists(absoluteSourceEntryPath);
+
+  if (!sourceEntryExists) {
+    nullifyTargetEntryPath(pathMap);
+
+    return;
+  }
+
+  const { entryDirectory } = pathMap;
+
+  entryDirectory ?
+    renameProjectDirectory(projectsDirectoryPath, pathMap) :
+      renameProjectFile(projectsDirectoryPath, pathMap);
+}
+
+function renameProjectFile(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath, targetEntryPath } = pathMap,
+        sourceFilePath = sourceEntryPath, ///
+        targetFilePath = targetEntryPath, ///
+        absoluteSourceFilePath = concatenatePaths(projectsDirectoryPath, sourceFilePath),
+        absoluteTargetFilePath = concatenatePaths(projectsDirectoryPath, targetFilePath),
+        targetFileExists = checkFileExists(absoluteTargetFilePath);
+
+  if (targetFileExists) {
+    nullifyEntryPaths(pathMap);
+
+    return;
+  }
+
+  try {
+    const oldEntryPath = absoluteSourceFilePath, ///
+          newEntryPath = absoluteTargetFilePath; ///
+
+    renameEntry(oldEntryPath, newEntryPath);  ///
+  } catch (error) {
+    nullifyEntryPaths(pathMap);
+  }
+}
+
+function renameProjectDirectory(projectsDirectoryPath, pathMap) {
+  const { sourceEntryPath, targetEntryPath } = pathMap,
+        sourceDirectoryPath = sourceEntryPath, ///
+        targetDirectoryPath = targetEntryPath, ///
+        absoluteSourceDirectoryPath = concatenatePaths(projectsDirectoryPath, sourceDirectoryPath),
+        absoluteTargetDirectoryPath = concatenatePaths(projectsDirectoryPath, targetDirectoryPath),
+        targetDirectoryExists = checkDirectoryExists(absoluteTargetDirectoryPath);
+
+  if (targetDirectoryExists) {
+    nullifyEntryPaths(pathMap);
+
+    return;
+  }
+
+  try {
+    const oldEntryPath = absoluteSourceDirectoryPath, ///
+          newEntryPath = absoluteTargetDirectoryPath; ///
+
+    renameEntry(oldEntryPath, newEntryPath);  ///
+  } catch (error) {
+    nullifyEntryPaths(pathMap);
+  }
+}

package/src/saveFile.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { File } from "occam-model";
+
+import { saveFile as saveFileEx } from "./utilities/fileSystem"
+
+export default function saveFile(projectsDirectoryPath, json, callback) {
+  const file = File.fromJSON(json),
+        success = saveFileEx(file, projectsDirectoryPath);
+
+  json = success; ///
+
+  callback(json);
+}