Make actions-ready

Author: uellenberg

.github/dependabot.yml

@@ -5,7 +5,7 @@
 
 version: 2
 updates:
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "daily"
+    - package-ecosystem: "npm" # See documentation for possible values
+      directory: "/" # Location of package manifests
+      schedule:
+          interval: "daily"

.gitignore

@@ -1,6 +1,5 @@
 .idea/
 node_modules/
-dist/
 *.iml
 yarn-error.log
 .env

.gitmodules

@@ -1,5 +1,22 @@
 # Upload Unit
-Upload Unit is a GitHub Action to upload a unit to Cratecode. It handles uploading lessons, subunits, and units, all under a single repository.
+
+Upload Unit is a GitHub Action to upload a unit to Cratecode. It handles uploading lessons, subunits, and units, all under a single action.
+
+# Examples
+
+## Upload a Manifest
+
+```yaml
+steps:
+    - uses: actions/checkout@v2
+
+    - uses: cratecode/upload-manifest@v1
+      with:
+          manifest: path/to/manifest
+          key: ${{ secrets.CRATECODE_API_KEY }}
+```
+
+# Usage
 
 Uploading works by creating a manifest file which imports other manifest files, and can also specify a unit to upload. This "root" manifest file commonly links to either subunits (which in turn link to lessons or other subunits) or lessons, which will be uploaded.
 
@@ -8,42 +25,69 @@ Instead of working with IDs directly, items are linked and mapped with "friendly
 Units can reference lessons or other units. If you need to use someone else's unit/lesson, you can use their ID by starting the ID with a ":" and placing it in the friendly name field.
 
 Unit manifest files contain the definition for the unit. That is, they include a starting lesson for the unit, and what lessons other lessons point to. They follow the following format:
+
 ```json
 {
-  "type": "unit",
-  "id": "Friendly Name",
-  "name": "Display Name",
-  "upload": [
-    "folder1/manifest.json"
-  ],
-  "start": "first_lesson",
-  "lessons": {
-    "first_lesson": {
-      "next": "next_lesson",
-      "requires": []
-    },
-    "next_lesson": {
-      "next": [],
-      "requires": [
-        "next_lesson"
-      ]
+    "type": "unit",
+    "id": "Friendly Name",
+    "name": "Display Name",
+    "upload": ["folder1/manifest.json"],
+    "start": "first_lesson",
+    "lessons": {
+        "first_lesson": {
+            "next": "next_lesson"
+        },
+        "next_lesson": {
+            "next": []
+        }
     }
-  }
 }
 ```
 
 Lesson manifest files include information about the lesson. They should be included in the directory containing the lesson's contents. For example, a lesson manifest might be in a folder that looks like:
+
 ```
-folder
- -- index.js
- -- manifest.json
- -- README.md
+folder/
+-- index.js
+-- manifest.json
+-- README.md
 ```
+
 During the uploading process, the manifest will not be uploaded. For a lesson manifest, the following format is used:
+
 ```json
 {
-  "type": "lesson",
-  "id": "Friendly Name",
-  "name": "Display Name"
+    "type": "lesson",
+    "id": "Friendly Name",
+    "name": "Display Name"
 }
-```
+```
+
+A typical setup might look like the below file tree, where the first manifest is the first example manifest and the second manifest is the second example manifest:
+
+```
+folder/
+-- manifest.json
+-- lessons/
+   -- lesson_1/
+      -- index.js
+      -- manifest.json
+      -- README.md
+```
+
+You may also subdivide your unit into multiple smaller units. In the example below, the first two manifests are unit manifests (like the first example manifest), while the second is a lesson manifest (like the second example manifest). In this example, the first manifest may upload the second manifest and link to the unit described by the second manifest, while the second manifest may upload the third and link to the lesson described by the third.
+
+```
+folder/
+-- manifest.json
+-- units/
+   -- unit_1/
+      -- manifest.json
+      -- lessons/
+         -- lesson_1/
+            -- index.js
+            -- manifest.json
+            -- README.md
+```
+
+As you can see, many configurations are possible. To look at an actual example, please head over to the [Cratecode Intro](https://github.com/Cratecode/intro.git) repository.

README.md

@@ -2,21 +2,13 @@ name: "Upload Unit"
 description: "Uploads a unit to Cratecode, as well as any included lessons."
 author: "Cratecode"
 inputs:
-  key:
-    required: true
-    description: "The API Key."
-  manifest:
-    required: true
-    description: "The manifest file to use to upload."
-    default: "manifest.json"
-  domain:
-    required: false
-    description: "The domain to upload to."
-    default: "https://cratecode.com"
-  websocket:
-    required: false
-    description: "The websocket location."
-    default: "wss://cratecode.com/container/"
+    key:
+        required: true
+        description: "The API Key."
+    manifest:
+        required: true
+        description: "The manifest file to use to upload."
+        default: "manifest.json"
 runs:
-  using: "node16"
-  main: "dist/index.js"
+    using: "node16"
+    main: "dist/index.js"

action.yml

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core = __importStar(require("@actions/core"));
+const client_1 = require("@cratecode/client");
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const manifest = core.getInput("manifest");
+    const key = core.getInput("key");
+    yield (0, client_1.upload)(manifest, key);
+}))();

build-proto.sh

@@ -1,34 +1,25 @@
 {
-  "name": "upload-unit",
-  "version": "1.0.0",
-  "scripts": {
-    "build": "tsc",
-    "proto": "./build-proto.sh"
-  },
-  "description": "A GitHub Action for uploading a unit to Cratecode.",
-  "main": "index.js",
-  "repository": "https://github.com/Cratecode/upload-unit.git",
-  "author": "Cratecode",
-  "license": "Apache-2.0",
-  "dependencies": {
-    "@actions/core": "^1.9.0",
-    "axios": "^0.27.2",
-    "form-data": "^4.0.0",
-    "walkdir": "^0.4.1",
-    "ws": "^8.8.0"
-  },
-  "devDependencies": {
-    "@protobuf-ts/plugin": "^2.6.0",
-    "@types/node": "^18.0.0",
-    "@types/ws": "^8.5.3",
-    "@typescript-eslint/eslint-plugin": "^5.28.0",
-    "@typescript-eslint/parser": "^5.28.0",
-    "eslint": "^8.17.0",
-    "prettier": "^2.7.0",
-    "typescript": "^4.7.3"
-  },
-  "optionalDependencies": {
-    "bufferutil": "^4.0.6",
-    "utf-8-validate": "^5.0.9"
-  }
+    "name": "upload-unit",
+    "version": "1.0.0",
+    "scripts": {
+        "build": "tsc"
+    },
+    "description": "A GitHub Action for uploading a unit to Cratecode.",
+    "main": "index.js",
+    "repository": "https://github.com/Cratecode/upload-unit.git",
+    "author": "Cratecode",
+    "license": "Apache-2.0",
+    "dependencies": {
+        "@actions/core": "^1.9.0",
+        "@cratecode/client": "^1.0.6"
+    },
+    "devDependencies": {
+        "@types/node": "^18.0.0",
+        "@typescript-eslint/eslint-plugin": "^5.28.0",
+        "@typescript-eslint/parser": "^5.28.0",
+        "eslint": "^8.17.0",
+        "prettier": "^2.7.0",
+        "typescript": "^4.7.3"
+    },
+    "optionalDependencies": {}
 }

dist/index.js

@@ -1,67 +1,9 @@
 import * as core from "@actions/core";
-import { readManifest } from "./manifest";
-import { websockets } from "./lesson";
+import { upload } from "@cratecode/client";
 
 (async () => {
     const manifest = core.getInput("manifest");
+    const key = core.getInput("key");
 
-    const state = {
-        itemCount: 0,
-        idsMap: {},
-    };
-
-    // Open the initial manifest.
-    await readManifest(state, null, null, manifest);
-
-    // Now, we should clean up websockets. If all websockets are closed, we can safely exit
-    // the program, otherwise we should wait 30 seconds, then force close them and force exit after 5 seconds.
-    if (websockets.some((ws) => ws.readyState !== ws.CLOSED)) {
-        setTimeout(() => {
-            for (const ws of websockets) {
-                if (ws.readyState !== ws.CLOSED) {
-                    ws.close();
-                }
-            }
-
-            setTimeout(() => {
-                process.exit(0);
-            }, 5000);
-        }, 30 * 1000);
-    }
+    await upload(manifest, key);
 })();
-
-/**
- * The application's state.
- */
-export interface State {
-    /**
-     * The number of requests sent.
-     */
-    itemCount: number;
-    /**
-     * A map from friendly names to IDs.
-     */
-    idsMap: Record<string, string>;
-}
-
-/**
- * Sleeps for a delay.
- * @param ms {number} - is the amount of time to sleep for.
- */
-export function sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-
-/**
- * Delays if the ratelimit has been hit.
- * @param state {State} - is the state.
- */
-export async function delay(state: State): Promise<void> {
-    if (++state.itemCount % 50 === 0) {
-        console.log("Hit ratelimit, sleeping.");
-        await sleep(60 * 1000);
-        console.log("Waking up.");
-    }
-}