@nanoforge-dev/editor 0.0.2-beta.7f94b8f → 0.0.2-beta.82a2d26

package/dist/server/chunks/{request-handler-guINVc1G.js → request-handler-BVHWtbqx.js}

@@ -1,11 +1,13 @@
-import { n as fail } from "./exports-CWOtdr_a.js";
+import { n as fail } from "./exports-D0uQzbjy.js";
 import { t as private_env } from "./shared-server-Cha0Qlv9.js";
 import { t as Exception } from "./const-Dy5RfQqP.js";
 import { n as PUBLIC_MODE, r as formatFrom, t as HttpClient } from "./format-DGOlJxF5.js";
-import { a as getProject, i as getOrCreateSession, l as tryAddProjectSession, o as resolveProject, r as generateKey, s as resolveSession, t as addProjectToSession } from "./session-DLCjVGKo.js";
+import { a as getProject, i as getOrCreateSession, l as tryAddProjectSession, o as resolveProject, r as generateKey, s as resolveSession, t as addProjectToSession } from "./session-By0bbFhg.js";
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
+import micromatch from "micromatch";
 import path, { dirname, join, resolve } from "node:path";
+import * as tar from "tar";
 import fs, { existsSync } from "node:fs";
 import { $ } from "bun";
 import { config } from "dotenv";
@@ -29,6 +31,11 @@ var getContext = async (event) => {
 		project
 	};
 };
+var getUrl = (url, query) => {
+	const entries = Object.entries(query ?? {}).filter(([, value]) => value !== void 0);
+	if (entries.length === 0) return url;
+	return `${url}?${new URLSearchParams(entries).toString()}`;
+};
 var setTokensInCookies = (cookies, { accessToken, refreshToken, tokenExpiresAt }) => {
 	cookies.set("accessToken", accessToken, {
 		httpOnly: true,
@@ -121,6 +128,11 @@ var AuthRepository = class extends BaseRepository {
 		return this.post(`/auth/refresh-token`, input);
 	}
 };
+var PackageRepository = class extends BaseRepository {
+	getAll(query) {
+		return this.get(getUrl(`/packages`, query), { offline: true });
+	}
+};
 var ProjectRepository = class extends BaseRepository {
 	getProject(id) {
 		return this.get(`/editor/projects/${id}`);
@@ -140,6 +152,7 @@ var getNoAuthApi = () => {
 	const isOnline = PUBLIC_MODE === "ONLINE";
 	return {
 		auth: new AuthRepository(client, isOnline),
+		packages: new PackageRepository(client, isOnline),
 		registry: new RegistryRepository(client, isOnline)
 	};
 };
@@ -151,6 +164,7 @@ var getApi = (cookies) => {
 	} }).useMiddlewares(useTokenMiddleware(cookies));
 	return {
 		auth: new AuthRepository(client),
+		packages: new PackageRepository(client),
 		projects: new ProjectRepository(client),
 		registry: new RegistryRepository(client)
 	};
@@ -285,6 +299,9 @@ var Cli = class {
 var resolveRootPath = (userPath) => {
 	return resolve(resolve(private_env.FS_ROOT ?? ""), userPath);
 };
+var resolveArchiveRootPath = () => {
+	return resolve(private_env.ARCHIVE_ROOT ?? "");
+};
 var FileSystemError = class extends Exception {
 	constructor(message) {
 		super("Bad Request", message, 400);
@@ -309,15 +326,18 @@ var ProjectDirectory = class {
 		this.projectPath = projectPath;
 		this._checkPathIsInsideProject();
 	}
-	read(recursive = false) {
+	read(recursive = false, createIfNotExist = false) {
+		if (createIfNotExist) {
+			if (!fs.existsSync(this.path)) this.create();
+		}
 		this._checkPathExists();
 		this._checkPathIsDir();
 		this._checkPathIsReadable();
 		return this._readDirContent(this.path, recursive);
 	}
-	create() {
+	create(path = this.path) {
 		this._checkPathNotExists();
-		fs.mkdirSync(this.path, { recursive: true });
+		fs.mkdirSync(path, { recursive: true });
 	}
 	delete(recursive = false) {
 		this._checkPathExists();
@@ -393,6 +413,64 @@ var ProjectDirectory = class {
 		return dirContent;
 	}
 };
+var archives = /* @__PURE__ */ new Map();
+var ArchiveSystem = class {
+	handler;
+	context;
+	_rootPath;
+	_sessionId;
+	constructor(handler, context) {
+		this.handler = handler;
+		this.context = context;
+		this._sessionId = context.session.id;
+		this._rootPath = resolveArchiveRootPath();
+	}
+	async create(ignoreFile = ".gitignore") {
+		const dir = this.handler.fs.getDirectory("");
+		let files = directoryContentToFileEntries(dir.read(true)).map((n) => n.startsWith("/") ? n.slice(1) : n);
+		try {
+			const ignore = await Bun.file(join(dir.path, ignoreFile)).text();
+			files = micromatch.not(files, ignore.split("\n").filter(Boolean), {
+				dot: true,
+				contains: true
+			});
+		} catch (e) {
+			console.warn(`Could not read ${ignoreFile} file`, e);
+		}
+		const id = `${this._resolveId()}.tgz`;
+		const path = join(this._rootPath, id);
+		await tar.c({
+			gzip: true,
+			file: path,
+			cwd: dir.path
+		}, files);
+		archives.set(id, {
+			sessionId: this._sessionId,
+			path
+		});
+		setTimeout(this._delete.bind(this, id), 1e3 * 60 * 15);
+		return id;
+	}
+	async get(id) {
+		const archive = archives.get(id);
+		if (!archive) throw new Exception("Not Found", "Archive not found", 404);
+		if (archive.sessionId !== this._sessionId) throw new Exception("Forbidden", "Archive is not yours", 403);
+		return Bun.file(archive.path);
+	}
+	async _delete(id) {
+		const archive = archives.get(id);
+		if (!archive) return;
+		try {
+			await Bun.file(archive.path).delete();
+			archives.delete(id);
+		} catch (e) {
+			console.error("Could not delete archive", e);
+		}
+	}
+	_resolveId() {
+		return `${this.context.project.path.split("/").pop() ?? "unknown"}-${(/* @__PURE__ */ new Date()).toISOString()}`;
+	}
+};
 var ProjectFile = class {
 	_path;
 	projectPath;
@@ -530,36 +608,33 @@ var FileSystem = class {
 };
 var Git = class {
 	_rootPath;
-	constructor() {
+	_token;
+	_path;
+	constructor(context) {
 		this._rootPath = resolve(private_env.FS_ROOT ?? "");
+		this._token = context.project.gateway?.token ?? null;
+		this._path = context.project.path;
 	}
-	async clone(url, options) {
+	async clone(url) {
 		const path = await this.resolvePath(url);
 		if (existsSync(path)) return path;
-		await this.runCommand("clone", [url, path], { ...options });
+		if (this._token) url = url.replace("https://github.com/", `https://oauth2:${this._token}@github.com/`);
+		await this.runCommand("clone", [url, path]);
 		return path;
 	}
-	async runCommand(command, params, options) {
-		let sshPath;
-		if (options?.sshKey) sshPath = await this.createSshKeyFile(options.sshKey);
+	async push() {
+		await this.runCommand("add", ["--all"], { path: this._path });
+		if ((await this.runCommand("status", [], { path: this._path })).stdout.includes("nothing to commit")) return;
+		await this.runCommand("commit", ["-m", `nanoforged at ${(/* @__PURE__ */ new Date()).toISOString()}`], { path: this._path });
+		await this.runCommand("push", [
+			"-u",
+			"origin",
+			"main"
+		], { path: this._path });
+	}
+	runCommand(command, params, options) {
 		const cwd = resolve(this._rootPath, options?.path ?? "");
-		const sshEnv = sshPath ? { GIT_SSH_COMMAND: `ssh -i ${sshPath}` } : {};
-		try {
-			await $`git ${command} ${params}`.cwd(cwd).env({
-				...process.env,
-				...sshEnv
-			});
-		} finally {
-			if (sshPath) await this.deleteSshKeyFile(sshPath);
-		}
-	}
-	async createSshKeyFile(sshKey) {
-		const path = `/tmp/nanoforge/${generateKey()}`;
-		await Bun.file(path).write(sshKey);
-		return path;
-	}
-	async deleteSshKeyFile(path) {
-		await Bun.file(path).delete();
+		return $`git ${command} ${params}`.cwd(cwd).env({ ...process.env });
 	}
 	async resolvePath(url) {
 		const basePath = url.split("/").pop()?.replace(".git", "");
@@ -664,8 +739,20 @@ var Loader = class {
 var PackageTypeEnum = /* @__PURE__ */ function(PackageTypeEnum) {
 	PackageTypeEnum["COMPONENT"] = "component";
 	PackageTypeEnum["SYSTEM"] = "system";
+	PackageTypeEnum["ASSET"] = "asset";
 	return PackageTypeEnum;
 }({});
+var PACKAGES_PATH = {
+	[PackageTypeEnum.COMPONENT]: "components",
+	[PackageTypeEnum.SYSTEM]: "systems",
+	[PackageTypeEnum.ASSET]: "assets"
+};
+PackageTypeEnum.COMPONENT, PackageTypeEnum.SYSTEM, PackageTypeEnum.ASSET;
+var PACKAGES_PATH_FORMATTER = {
+	[PackageTypeEnum.COMPONENT]: (n) => formatFrom.all(n).toKebab() + ".component",
+	[PackageTypeEnum.SYSTEM]: (n) => formatFrom.all(n).toKebab() + ".system",
+	[PackageTypeEnum.ASSET]: (n) => n
+};
 var MANIFEST_TITLES = {
 	[PackageTypeEnum.COMPONENT]: "EDITOR_COMPONENT_MANIFEST",
 	[PackageTypeEnum.SYSTEM]: "EDITOR_SYSTEM_MANIFEST"
@@ -723,77 +810,97 @@ var getManifestFromNode = (source) => {
 	if (!ts.isObjectLiteralExpression(init)) return null;
 	return parseElement(init);
 };
-var parseManifest = (title, source) => {
+var parseManifest = (type, source) => {
 	const id = getName(source);
-	const manifest = getManifestFromNode(findManifestNode(title, source));
+	const manifest = getManifestFromNode(findManifestNode(MANIFEST_TITLES[type], source));
 	if (!id || !manifest) return null;
 	return {
 		id,
+		type,
 		...manifest
 	};
 };
 var resolveManifest = (type, content) => {
-	const source = ts.createSourceFile("tmp.ts", content, ts.ScriptTarget.ESNext, true);
-	return parseManifest(MANIFEST_TITLES[type], source);
+	return parseManifest(type, ts.createSourceFile("tmp.ts", content, ts.ScriptTarget.ESNext, true));
 };
-var PackageHandler = class {
+var resolveSave = (type, name, path, manifest) => {
+	const base = {
+		name,
+		path
+	};
+	if (type === PackageTypeEnum.SYSTEM) return base;
+	return {
+		...base,
+		paramsNames: manifest.params.map(({ name }) => name)
+	};
+};
+var ManifestHandler = class {
 	handler;
 	constructor(handler) {
 		this.handler = handler;
 	}
-	async installComponent(name) {
-		const rc = await this.handler._api.registry.getPackage(name);
-		if (rc.type !== "component") throw new Error(`Can only add component: ${name} is a ${rc.type}`);
-		this.handler._cli.install([name], { server: this.handler._part === "server" || void 0 });
-		return this._getNewComponentPackage(rc.name, rc._file);
+	resolveFromName(type, rawName) {
+		return this.resolveFromFilename(type, PACKAGES_PATH_FORMATTER[type](rawName));
 	}
-	async installSystem(name) {
-		const rs = await this.handler._api.registry.getPackage(name);
-		if (rs.type !== "system") throw new Error(`Can only add system: ${name} is a ${rs.type}`);
-		this.handler._cli.install([name], { server: this.handler._part === "server" || void 0 });
-		return this._getNewSystemPackage(rs.name, rs._file);
+	resolveFromFilename(type, filename) {
+		const path = join(PACKAGES_PATH[type], filename);
+		return this.resolveFromPath(type, path);
+	}
+	resolveFromPath(type, path) {
+		const manifest = this._resolveManifest(type, path);
+		return {
+			manifest,
+			save: resolveSave(type, manifest.id, path, manifest)
+		};
+	}
+	_resolveManifest(type, path) {
+		return this._findPackageManifest((p) => this._getPackageManifest(type, p), path);
+	}
+	_getPackageManifest(type, path) {
+		return resolveManifest(type, this.handler._rootFs.getFile(this._resolvePartPath(path)).read());
+	}
+	_findPackageManifest(manifestGetter, path) {
+		const manifest = [
+			"",
+			".ts",
+			".js"
+		].reduce((result, p) => {
+			if (result) return result;
+			try {
+				return manifestGetter(path + p);
+			} catch (e) {
+				if (!(e instanceof FileSystemError)) throw e;
+			}
+		}, void 0);
+		if (!manifest) throw new FileSystemError("Can't find package manifest");
+		return manifest;
+	}
+	_resolvePartPath(path) {
+		return join(this.handler._part, path);
+	}
+};
+var PackageHandler = class {
+	handler;
+	manifestHandler;
+	constructor(handler) {
+		this.handler = handler;
+		this.manifestHandler = new ManifestHandler(handler);
+	}
+	async installPackages(names) {
+		if (names.length === 0) return [];
+		this.handler._cli.install(names, { server: this.handler._part === "server" || void 0 });
+		return Promise.all(names.map(async (name) => {
+			const r = await this.handler._api.registry.getPackage(name);
+			return this._resolvesPackage(r.type, r._file);
+		}));
 	}
-	/**
-	* Create a new component in the project
-	* @beta function to be reworked
-	*
-	* @param {string} name - Name of the component
-	*/
 	createComponent(name) {
 		this._createPackage(PackageTypeEnum.COMPONENT, name);
-		return this._getNewComponentPackage(formatFrom.all(name).toPascal() + "Component", formatFrom.all(name).toKebab() + ".component");
+		return this.manifestHandler.resolveFromName(PackageTypeEnum.COMPONENT, name);
 	}
-	/**
-	* Create a new system in the project and update the save file
-	* @beta function to be reworked
-	*
-	* @param {string} name - Name of the system
-	*/
 	createSystem(name) {
 		this._createPackage(PackageTypeEnum.SYSTEM, name);
-		return this._getNewSystemPackage(formatFrom.all(name).toCamel() + "System", formatFrom.all(name).toKebab() + ".system");
-	}
-	/**
-	* Get the manifest of the component
-	* @beta function to be reworked
-	*
-	* @param {string} path - Path from `/<client|server>`
-	*
-	* @returns Manifest of the component
-	*/
-	getComponentManifest(path) {
-		return this._getPackageManifest(PackageTypeEnum.COMPONENT, path);
-	}
-	/**
-	* Get the manifest of the system
-	* @beta function to be reworked
-	*
-	* @param {string} path - Path from `/<client|server>`
-	*
-	* @returns Manifest of the system
-	*/
-	getSystemManifest(path) {
-		return this._getPackageManifest(PackageTypeEnum.SYSTEM, path);
+		return this.manifestHandler.resolveFromName(PackageTypeEnum.SYSTEM, name);
 	}
 	async getComponents() {
 		return this._resolvesPackages(PackageTypeEnum.COMPONENT);
@@ -801,22 +908,18 @@ var PackageHandler = class {
 	async getSystems() {
 		return this._resolvesPackages(PackageTypeEnum.SYSTEM);
 	}
+	async getAssets() {
+		return this._resolvesPackages(PackageTypeEnum.ASSET);
+	}
 	_resolvesPackages(type) {
-		const basePath = type === PackageTypeEnum.COMPONENT ? "./components" : "./systems";
-		const content = this.handler.fs.getDirectory(basePath).read(true);
-		return this._resolvesPackageFilesPathFromContent(content).map((path) => this._resolvesPackage(type, join(basePath, path)));
+		const basePath = PACKAGES_PATH[type];
+		const content = this.handler.fs.getDirectory(basePath).read(true, true);
+		return this._resolvesPackageFilesPathFromContent(content).map((path) => this._resolvesPackage(type, path, basePath));
 	}
-	_resolvesPackage(type, path) {
-		const manifest = this._getPackageManifest(type, path);
-		const res = {
-			manifest,
-			save: {
-				name: manifest.id,
-				path
-			}
-		};
-		if (type === PackageTypeEnum.COMPONENT) res.save.params = manifest.params.map(({ name }) => name);
-		return res;
+	_resolvesPackage(type, filename, basePath = PACKAGES_PATH[type]) {
+		const path = join(basePath, filename);
+		if (type === PackageTypeEnum.ASSET) return { path };
+		return this.manifestHandler.resolveFromPath(type, path);
 	}
 	_resolvesPackageFilesPathFromContent(content, path = "") {
 		const files = content.files.map((file) => join(path, file));
@@ -826,56 +929,12 @@ var PackageHandler = class {
 		});
 		return [...files, ...directories.flat()];
 	}
-	_getNewComponentPackage(name, fileName) {
-		const path = `./components/${fileName}`;
-		const manifest = this._findPackageManifest((p) => this.getComponentManifest(p), path);
-		return {
-			manifest,
-			save: {
-				name,
-				path,
-				paramsNames: manifest.params.map(({ name }) => name)
-			}
-		};
-	}
-	_getNewSystemPackage(name, fileName) {
-		const path = `./systems/${fileName}`;
-		return {
-			manifest: this._findPackageManifest((p) => this.getSystemManifest(p), path),
-			save: {
-				name,
-				path
-			}
-		};
-	}
-	_findPackageManifest(manifestGetter, path) {
-		const manifest = [
-			"",
-			".ts",
-			".js"
-		].reduce((result, p) => {
-			if (result) return result;
-			try {
-				return manifestGetter(path + p);
-			} catch (e) {
-				if (!(e instanceof FileSystemError)) throw e;
-			}
-		}, void 0);
-		if (!manifest) throw new FileSystemError("Can't find package manifest");
-		return manifest;
-	}
 	_createPackage(type, name) {
 		this.handler._cli.create(type, {
 			name,
 			server: this.handler._part === "server" || void 0
 		});
 	}
-	_getPackageManifest(type, path) {
-		return resolveManifest(type, this.handler._rootFs.getFile(this._resolvePartPath(path)).read());
-	}
-	_resolvePartPath(path) {
-		return join(this.handler._part, path);
-	}
 };
 var SaveHandler = class {
 	handler;
@@ -974,6 +1033,7 @@ var Handler = class {
 	_fsCache;
 	_gitCache;
 	_projectCache;
+	_archiveCache;
 	constructor(context, event, body) {
 		this._context = context;
 		this._event = event;
@@ -988,6 +1048,7 @@ var Handler = class {
 		this._cliCache = void 0;
 		this._fsCache = void 0;
 		this._gitCache = void 0;
+		this._archiveCache = void 0;
 	}
 	get event() {
 		return this._event;
@@ -1008,13 +1069,17 @@ var Handler = class {
 		return this._fsCache;
 	}
 	get git() {
-		if (!this._gitCache) this._gitCache = new Git();
+		if (!this._gitCache) this._gitCache = new Git(this._context);
 		return this._gitCache;
 	}
 	get project() {
 		if (!this._projectCache) this._projectCache = new ProjectManager(this, this._context);
 		return this._projectCache;
 	}
+	get archive() {
+		if (!this._archiveCache) this._archiveCache = new ArchiveSystem(this, this._context);
+		return this._archiveCache;
+	}
 };
 var DEFAULT_OPTIONS = {
 	onlineOnly: false,
@@ -1067,6 +1132,7 @@ var handleError = (e) => {
 		error: e.error,
 		message: e.message
 	}, { status: e.status });
+	console.error(e);
 	return Response.json({
 		error: "Internal Server Error",
 		message: e
@@ -1084,6 +1150,6 @@ var useRequestHandler = (callback, options) => {
 	};
 };
 //#endregion
-export { useRequestHandler as i, loadProjectFromId as n, useActionHandler as r, loadProject as t };
+export { useRequestHandler as a, useActionHandler as i, loadProject as n, loadProjectFromId as r, Git as t };
 
-//# sourceMappingURL=request-handler-guINVc1G.js.map
+//# sourceMappingURL=request-handler-BVHWtbqx.js.map