@phreshos/node 0.1.0

package/dist/uploads.js

@@ -0,0 +1,110 @@
+import { isUploadFile } from "@phreshos/core";
+import { randomUUID } from "node:crypto";
+import { createReadStream, createWriteStream, mkdirSync } from "node:fs";
+import { rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+/** Owner-local implementation of the System's opaque upload collection. */
+export default class Uploads {
+    ask;
+    accessPromise = null;
+    constructor(ask) {
+        this.ask = ask;
+    }
+    async write(value) {
+        const access = await this.access();
+        const source = content(value);
+        const identity = randomUUID();
+        const file = `${identity}.${source.extension}`;
+        const temporary = join(access.path, `.${identity}.uploading`);
+        const destination = join(access.path, file);
+        let size = 0;
+        mkdirSync(access.path, { recursive: true });
+        try {
+            await pipeline(Readable.fromWeb(source.stream), async function* (chunks) {
+                for await (const chunk of chunks) {
+                    size += chunk.byteLength;
+                    if (size > access.limit)
+                        throw new Error(`The upload exceeds ${access.limit / 1024 / 1024 / 1024} GB`);
+                    yield chunk;
+                }
+            }, createWriteStream(temporary, { flags: "wx" }));
+            await rename(temporary, destination);
+        }
+        catch (error) {
+            await rm(temporary, { force: true }).catch(() => undefined);
+            throw error;
+        }
+        const upload = await this.stat(file);
+        if (!upload)
+            throw new Error("The completed upload could not be described");
+        return upload;
+    }
+    async stream(file) {
+        requireFile(file);
+        const access = await this.access();
+        return Readable.toWeb(createReadStream(join(access.path, file)));
+    }
+    async bytes(file) { return new Uint8Array(await new Response(await this.stream(file)).arrayBuffer()); }
+    async text(file) { return new Response(await this.stream(file)).text(); }
+    async json(file) { return JSON.parse(await this.text(file)); }
+    async stat(file) {
+        requireFile(file);
+        return await this.ask({ capability: "uploads", operation: "stat", file });
+    }
+    access() {
+        if (!this.accessPromise) {
+            const resolving = this.ask({ capability: "uploads", operation: "access" }).then(value => {
+                const access = value;
+                if (!access || typeof access.path !== "string" || typeof access.limit !== "number")
+                    throw new Error("The System returned invalid upload access");
+                return { path: access.path, limit: access.limit };
+            });
+            const retained = resolving.catch(error => {
+                if (this.accessPromise === retained)
+                    this.accessPromise = null;
+                throw error;
+            });
+            this.accessPromise = retained;
+        }
+        return this.accessPromise;
+    }
+}
+function requireFile(file) {
+    if (!isUploadFile(file))
+        throw new Error("That is not an upload file");
+}
+function content(value) {
+    if (typeof File !== "undefined" && value instanceof File) {
+        const type = value.type || "application/octet-stream";
+        return { stream: value.stream(), extension: extension(value.name, type) };
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob)
+        return { stream: value.stream(), extension: extension("", value.type) };
+    if (value instanceof ReadableStream)
+        return { stream: value, extension: "bin" };
+    if (value instanceof Uint8Array)
+        return { stream: new Blob([bytes(value)]).stream(), extension: "bin" };
+    if (value instanceof ArrayBuffer)
+        return { stream: new Blob([value]).stream(), extension: "bin" };
+    if (typeof value === "string")
+        return { stream: new Blob([value]).stream(), extension: "txt" };
+    return { stream: new Blob([JSON.stringify(value)]).stream(), extension: "json" };
+}
+function bytes(value) {
+    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+}
+function extension(name, type) {
+    const named = /\.([a-z0-9]+)$/i.exec(name)?.[1]?.toLowerCase();
+    if (named && /^[a-z0-9]+$/.test(named))
+        return named;
+    return extensions[type] ?? "bin";
+}
+const extensions = {
+    "application/json": "json",
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/svg+xml": "svg",
+    "text/plain": "txt"
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@phreshos/node",
+  "version": "0.1.0",
+  "description": "Node.js access to PhreshOS and Program projects.",
+  "type": "module",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    }
+  },
+  "files": ["dist", "LICENSE", "README.md"],
+  "author": "Zohayr SLILEH",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PhreshOS/node.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "packageManager": "bun@1.3.14",
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "check": "tsc --noEmit",
+    "build": "node --run clean && tsc --noEmit false --outDir dist --rootDir source",
+    "test": "node --run build && node --test tests/*.test.mjs",
+    "verify": "node --run check && node --run test",
+    "prepack": "node --run build"
+  },
+  "dependencies": {
+    "@phreshos/core": "^0.1.21",
+    "adm-zip": "^0.6.0",
+    "jiti": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.8",
+    "@types/node": "^26.2.0",
+    "typescript": "^6.0.3"
+  }
+}