@sealcode/sealgen 0.1.0

package/lib/utils/import-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-path.js","sourceRoot":"","sources":["../../src/utils/import-path.ts"],"names":[],"mappings":";;;;;;AAAA,+BAAyC;AACzC,oDAA6B;AAC7B,MAAM,MAAM,GAAG,gBAAO,CAAC,SAAS,CAAC,CAAC;AAElC,SAAgB,UAAU,CACzB,mBAA2B,EAC3B,mBAA2B;IAE3B,IAAI,MAAM,GAAG,eAAQ,CACpB,cAAO,CAAC,MAAM,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAC5C,MAAM,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CACvD,CAAC;IACF,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE;QACrB,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;KACvB;IACD,OAAO,MAAM,CAAC;AACf,CAAC;AAZD,gCAYC;AAED,SAAgB,eAAe,CAC9B,mBAA2B;IAE3B,OAAO,UAAU,mBAA2B;QAC3C,OAAO,UAAU,CAAC,mBAAmB,EAAE,mBAAmB,CAAC,CAAC;IAC7D,CAAC,CAAC;AACH,CAAC;AAND,0CAMC"}

package/lib/utils/question.js

@@ -0,0 +1,34 @@
+"use strict";
+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 });
+exports.question = void 0;
+const readline_1 = require("readline");
+function question(text, validator) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rl = readline_1.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        let answer = "";
+        while (answer == "" || !validator(answer)) {
+            // eslint-disable-next-line no-await-in-loop
+            answer = yield new Promise((resolve) => rl.question(text, resolve));
+            if (!validator(answer)) {
+                // eslint-disable-next-line no-console
+                console.log("Try again");
+            }
+        }
+        rl.close();
+        return answer;
+    });
+}
+exports.question = question;
+//# sourceMappingURL=question.js.map

package/lib/utils/question.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"question.js","sourceRoot":"","sources":["../../src/utils/question.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,uCAA2C;AAE3C,SAAsB,QAAQ,CAAC,IAAY,EAAE,SAAsC;;QAClF,MAAM,EAAE,GAAG,0BAAe,CAAC;YAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,MAAM,EAAE,OAAO,CAAC,MAAM;SACtB,CAAC,CAAC;QACH,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,OAAO,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC1C,4CAA4C;YAC5C,MAAM,GAAG,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;YACpE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;gBACvB,sCAAsC;gBACtC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;aACzB;SACD;QAED,EAAE,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,MAAM,CAAC;IACf,CAAC;CAAA;AAjBD,4BAiBC"}

package/lib/utils/walk.js

@@ -0,0 +1,35 @@
+"use strict";
+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 });
+exports.walk = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function walk(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = yield fs_1.promises.readdir(dir);
+        let ret = [];
+        for (const entry of entries) {
+            const fullpath = path_1.resolve(dir, entry);
+            // eslint-disable-next-line no-await-in-loop
+            const info = yield fs_1.promises.stat(fullpath);
+            if (info.isDirectory()) {
+                // eslint-disable-next-line no-await-in-loop
+                ret = [...ret, ...(yield walk(fullpath))];
+            }
+            else {
+                ret = [...ret, fullpath];
+            }
+        }
+        return ret;
+    });
+}
+exports.walk = walk;
+//# sourceMappingURL=walk.js.map

package/lib/utils/walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.js","sourceRoot":"","sources":["../../src/utils/walk.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2BAAoC;AACpC,+BAA+B;AAE/B,SAAsB,IAAI,CAAC,GAAW;;QACrC,MAAM,OAAO,GAAG,MAAM,aAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,GAAG,GAAa,EAAE,CAAC;QACvB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;YAC5B,MAAM,QAAQ,GAAG,cAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACrC,4CAA4C;YAC5C,MAAM,IAAI,GAAG,MAAM,aAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAErC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;gBACvB,4CAA4C;gBAC5C,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;aAC1C;iBAAM;gBACN,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,QAAQ,CAAC,CAAC;aACzB;SACD;QACD,OAAO,GAAG,CAAC;IACZ,CAAC;CAAA;AAhBD,oBAgBC"}

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@sealcode/sealgen",
+	"version": "0.1.0",
+	"description": "Module to automate adding routes and collections to a sealious application",
+	"main": "lib/index.js",
+	"scripts": {
+		"test": "node test.js",
+		"build": "tsc",
+		"prepare": "npm run build",
+		"test-reports": "npm run build && rm -fr .xunit coverage && npm run test -- --cover --test-report"
+	},
+	"bin": {
+		"sealgen": "./lib/index.js"
+	},
+	"author": "",
+	"license": "ISC",
+	"devDependencies": {
+		"@types/mocha": "^9.0.0",
+		"@typescript-eslint/eslint-plugin": "^4.29.3",
+		"@typescript-eslint/parser": "^4.29.3",
+		"eslint": "^7.32.0",
+		"eslint-config-prettier": "^8.3.0",
+		"eslint-plugin-prettier": "^3.4.1",
+		"eslint-plugin-with-tsc-error": "^0.0.7",
+		"mocha": "^9.1.1",
+		"mri": "^1.1.6",
+		"nyc": "^15.1.0",
+		"prettier": "^2.3.2",
+		"source-map-support": "^0.5.19",
+		"ts-node": "^10.2.1",
+		"typescript": "^4.3.5"
+	},
+	"types": "./@types/index.d.ts",
+	"dependencies": {
+		"@sealcode/ts-predicates": "^0.2.1",
+		"locreq": "^2.0.2"
+	}
+}

package/src/add-collection.ts

@@ -0,0 +1,30 @@
+import { resolve } from "path";
+import _locreq from "locreq";
+import { promises as fs, existsSync } from "fs";
+import { question } from "./utils/question";
+import { collectionTemplate } from "./templates/collection";
+import { generateCollections } from "./generate-collections";
+const target_locreq = _locreq(process.cwd());
+
+export async function addCollection(): Promise<void> {
+	const collection_name = await question(
+		'What\'s the name of the collection class (e.g. "SecretDocuments", must start with a capital letter): ',
+		(s: string) => s.length > 3 && s[0].toUpperCase() == s[0]
+	);
+	const url = await question(
+		"Enter the url-friendly name for the collection (e.g. secret-documents): ",
+		(s: string) => !s.includes("/") && !s.includes(" ")
+	);
+	const file_path = target_locreq.resolve(`src/back/collections/${url}.ts`);
+
+	if (existsSync(file_path)) {
+		// eslint-disable-next-line no-console
+		console.error(`ERROR: File ${file_path} already exists.`);
+		return;
+	}
+	await fs.mkdir(resolve(file_path, "../"), { recursive: true });
+	await fs.writeFile(file_path, collectionTemplate(collection_name));
+	// eslint-disable-next-line no-console
+	console.log(`${file_path} created`);
+	await generateCollections();
+}

package/src/add-route.ts

@@ -0,0 +1,49 @@
+import { resolve } from "path";
+import { promises as fs, existsSync } from "fs";
+import { question } from "./utils/question";
+import { pageTemplate } from "./templates/page";
+import { formTemplate } from "./templates/form";
+import { testTemplate } from "./templates/route-test";
+import { escape_url_params } from "./utils/escape-url-params";
+
+import _locreq from "locreq";
+import { generateRoutes } from "./generate-routes";
+const target_locreq = _locreq(process.cwd());
+
+export async function addRoute(): Promise<void> {
+	const action = await question(
+		'What\'s the name of the action (e.g. "AddUser"): ',
+		(s: string) => s.length > 3
+	);
+	const url = await question(
+		"Enter a full absolute answer for the new route (e.g. /admin/users/add): ",
+		(s: string) => s.trim()[0] == "/"
+	);
+	const mode =
+		(await question("Is this a page (p) or a form (f)? ", (a: string) =>
+			["p", "f"].includes(a.toLowerCase())
+		)) == "p"
+			? "page"
+			: "form";
+	const file_path = target_locreq.resolve(
+		`src/back/routes/${escape_url_params(url)}.${mode}.ts`
+	);
+	const test_file_path = target_locreq.resolve(
+		`src/back/routes/${escape_url_params(url)}.test.ts`
+	);
+	const template = mode == "page" ? pageTemplate : formTemplate;
+
+	if (existsSync(file_path)) {
+		// eslint-disable-next-line no-console
+		console.error(`ERROR: File ${file_path} already exists.`);
+		return;
+	}
+	await fs.mkdir(resolve(file_path, "../"), { recursive: true });
+	await fs.writeFile(file_path, template(action, file_path));
+	await fs.writeFile(test_file_path, testTemplate(action, file_path));
+	// eslint-disable-next-line no-console
+	console.log(`${file_path} created`);
+	// eslint-disable-next-line no-console
+	console.log(`${test_file_path} created`);
+	await generateRoutes();
+}

package/src/example.test.ts

@@ -0,0 +1,11 @@
+import { Example } from "./index";
+import * as assert from "assert";
+
+describe("Example", () => {
+	describe("example", () => {
+		it("should equal 'example'", () => {
+			const example = new Example();
+			assert.equal(example.example(), "example");
+		});
+	});
+});

package/src/generate-collections.ts

@@ -0,0 +1,72 @@
+import _locreq from "locreq";
+import { promises as fs } from "fs";
+import { assertType, predicates } from "@sealcode/ts-predicates";
+
+const target_locreq = _locreq(process.cwd());
+
+async function extractCollectionClassname(
+	full_file_path: string
+): Promise<string> {
+	const file_content = await fs.readFile(full_file_path, "utf-8");
+	const result = file_content.match(/export default class (\w+)/);
+	if (result === null) {
+		throw new Error("Missing 'export default class' statement?");
+	}
+	return assertType(
+		result[1],
+		predicates.string,
+		"Missing export default class?"
+	);
+}
+
+export async function generateCollections(): Promise<void> {
+	const collections_dir = target_locreq.resolve("src/back/collections");
+	const files = (await fs.readdir(collections_dir)).filter(
+		(f) => !f.match(/\.(sub)?test\./) && f != "collections.ts"
+	);
+	const file_data = await Promise.all(
+		files.map(async (file) => {
+			const full_path = target_locreq.resolve(
+				"src/back/collections/" + file
+			);
+			const class_name = await extractCollectionClassname(full_path);
+			return {
+				class_name,
+				file,
+				full_path,
+				urlname: file.replace(".ts", ""),
+			};
+		})
+	);
+
+	const content = `// DO NOT EDIT! This file is generated automaticaly with 'npm run generate-collections'
+import { App } from "sealious";
+
+${file_data
+	.map(
+		({ class_name, urlname }) =>
+			`import _${class_name} from "./${urlname}";`
+	)
+	.join("\n")}
+	
+${file_data
+	.map(
+		({ class_name }) => `export const ${class_name} = new _${class_name}();`
+	)
+	.join("\n")}
+
+export const collections = {
+	...App.BaseCollections,
+${file_data
+	.map(({ class_name, urlname }) => `	"${urlname}": ${class_name},`)
+	.join("\n")}
+};`;
+	await fs.writeFile(
+		target_locreq.resolve("src/back/collections/collections.ts"),
+		content
+	);
+	// eslint-disable-next-line no-console
+	console.log(
+		"Successfuly generated new src/back/collections/collections.ts file"
+	);
+}

package/src/generate-routes.ts

@@ -0,0 +1,78 @@
+import { promises as fs } from "fs";
+import { relative } from "path";
+import _locreq from "locreq";
+import { walk } from "./utils/walk";
+import { importPath } from "./utils/import-path";
+import { assertType, predicates } from "@sealcode/ts-predicates";
+import { unescape_url_params } from "./utils/escape-url-params";
+
+const locreq = _locreq(__dirname);
+
+async function extractActionName(full_file_path: string): Promise<string> {
+	const file_content = await fs.readFile(full_file_path, "utf-8");
+	const result = file_content.match(/export const actionName = "(\w+)"/);
+	if (result === null) {
+		throw new Error("Missing 'export const actionName' statement?");
+	}
+	return assertType(
+		result[1],
+		predicates.string,
+		"Missing export default class?"
+	);
+}
+
+export async function generateRoutes(): Promise<void> {
+	const files = await Promise.all(
+		(
+			await walk(locreq.resolve("src/back/routes"))
+		)
+			.filter((f) => f.endsWith(".page.ts") || f.endsWith(".form.ts"))
+			.map(async (fullpath) => ({
+				fullpath,
+				actionName: await extractActionName(fullpath),
+				url: unescape_url_params(
+					"/" +
+						relative(
+							locreq.resolve("src/back/routes"),
+							fullpath
+						).replace(/\..+/, "")
+				),
+			}))
+	);
+
+	await fs.writeFile(
+		locreq.resolve("src/back/routes/routes.ts"),
+		`// DO NOT EDIT! This file is generated automaticaly with npm run generate-routes
+
+import Router from "@koa/router";
+import { Middlewares } from "sealious";
+
+${files
+	.map(
+		({ actionName, fullpath }) =>
+			`import { default as ${actionName} } from "${importPath(
+				locreq.resolve("src/back/routes/routes.ts"),
+				fullpath
+			)}";`
+	)
+	.join("\n")}
+
+${files
+	.map(({ actionName, url }) => `export const ${actionName}URL = "${url}";`)
+	.join("\n")}
+
+export default function mountAutoRoutes(router: Router) {
+${files
+	.map(
+		({
+			actionName,
+		}) => `	router.use(${actionName}URL, Middlewares.extractContext(), Middlewares.parseBody());
+	${actionName}.mount(router, ${actionName}URL);`
+	)
+	.join("\n\n")}
+}
+`
+	);
+	// eslint-disable-next-line no-console
+	console.log("Successfuly generated new src/back/routes/routes.ts file");
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { addCollection } from "./add-collection";
+import { addRoute } from "./add-route";
+import { generateCollections } from "./generate-collections";
+import { generateRoutes } from "./generate-routes";
+
+const actions: Record<string, () => Promise<void> | undefined> = {
+	"add-collection": addCollection,
+	"add-route": addRoute,
+	"generate-collections": generateCollections,
+	"generate-routes": generateRoutes,
+	default: async function () {
+		console.log("Usage: `sealscript <action>`");
+		console.log(
+			`Available actions: ${Object.keys(actions)
+				.filter((e) => e != "default")
+				.join(", ")}`
+		);
+	},
+};
+
+void (async function () {
+	const action = process.argv.at(-1);
+	actions;
+	const fn = actions[action || "default"] || actions.default;
+	await fn();
+})();

package/src/templates/collection.ts

@@ -0,0 +1,11 @@
+export function collectionTemplate(collection_name: string) {
+	return `import { Collection, FieldTypes, Policies } from "sealious";
+
+export default class ${collection_name} extends Collection {
+	fields = {
+		content: new FieldTypes.Text(),
+	};
+	defaultPolicy = new Policies.Public();
+}
+`;
+}

package/src/templates/form.ts

@@ -0,0 +1,42 @@
+import { curryImportPath } from "../utils/import-path";
+
+export const formTemplate = (action_name: string, newfilefullpath: string) => {
+	const rel = curryImportPath(newfilefullpath);
+	return `import { BaseContext } from "koa";
+import Users from "${rel("src/back/collections/users")}";
+import { FormHeader, SimpleInput } from "${rel("src/back/forms/controls")}";
+import { FormField } from "${rel("src/back/forms/field")}";
+import Form, { FormData } from "${rel("src/back/forms/form")}";
+import { collectionFieldValidator } from "${rel("src/back/forms/validator")}";
+import html from "${rel("src/back/html")}";
+
+export const actionName = "${action_name}";
+
+export default new(class ${action_name}Form extends Form {
+	defaultSuccessMessage = "Pomyślnie utworzono użytkownika";
+
+	fields = [new FormField("email", true, collectionFieldValidator(Users.fields.email))];
+
+	controls = [
+		new FormHeader("Enter your email address"),
+		new SimpleInput("email", { label: "Your email", type: "email" }),
+	];
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: BaseContext) {
+		return { canAccess: true, message: "" };
+	}
+
+	async onSubmit(ctx: BaseContext, values: Record<"email", string>) {
+		await ctx.$app.collections.users.create(ctx.$context, {
+			username: values.email,
+			...values,
+		});
+	}
+
+	async render(ctx: BaseContext, data: FormData, path: string) {
+		return html(ctx, "${action_name}", await super.render(ctx, data, path));
+	}
+})();
+`;
+};

package/src/templates/page.ts

@@ -0,0 +1,23 @@
+import { importPath } from "../utils/import-path";
+
+export const pageTemplate = (
+	action_name: string,
+	fullpath: string
+) => `import { BaseContext } from "koa";
+import { tempstream } from "tempstream";
+import { Page } from "${importPath(fullpath, "src/back/page/page")}";
+
+export const actionName = "${action_name}";
+
+export default new (class ${action_name}Page extends Page {
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: BaseContext) {
+		return { canAccess: true, message: "" };
+	}
+
+	async render(ctx: BaseContext) {
+		return tempstream/* HTML */ \`<div></div>\`;
+	}
+})();
+`;

package/src/templates/route-test.ts

@@ -0,0 +1,23 @@
+import { curryImportPath } from "../utils/import-path";
+
+export function testTemplate(action_name: string, new_file_fullpath: string) {
+	const rel = curryImportPath(new_file_fullpath);
+	return `import { withProdApp } from "${rel("src/back/test_utils/with-prod-app")}";
+import { LONG_TEST_TIMEOUT, webhintURL } from "${rel("src/back/test_utils/webhint")}";
+import { ${action_name}URL } from "${rel("src/back/routes/routes")}";
+
+describe("${action_name}", () => {
+	it("doesn't crash", async function () {
+		this.timeout(LONG_TEST_TIMEOUT);
+		return withProdApp(async ({ base_url, rest_api }) => {
+			await rest_api.get(${action_name}URL);
+			await webhintURL(base_url + ${action_name}URL);
+			// alternatively you can use webhintHTML for faster but less precise scans
+			// or for scanning responses of requests that use some form of authorization:
+			// const response = await rest_api.get(${action_name}URL);
+			// await webhintHTML(response);
+		});
+	});
+});
+`;
+}

package/src/tsconfig.json

@@ -0,0 +1,18 @@
+{
+	"compilerOptions": {
+		"module": "ESNext",
+		"moduleResolution": "node",
+		"noImplicitAny": true,
+		"noImplicitThis": true,
+		"strictNullChecks": true,
+		"target": "ES2020",
+		"lib": ["es6", "esnext"],
+		"outDir": "../../dist/scripts",
+		"checkJs": true,
+		"allowJs": true,
+		"resolveJsonModule": true,
+		"sourceMap": true,
+		"skipLibCheck": true
+	},
+	"include": ["./**/*", "./*"]
+}

package/src/utils/escape-url-params.ts

@@ -0,0 +1,13 @@
+export function escape_url_params(url: string): string {
+	return url
+		.split("/")
+		.map((e) => (e.startsWith(":") ? `[${e.slice(1)}]` : e))
+		.join("/");
+}
+
+export function unescape_url_params(url: string): string {
+	return url
+		.split("/")
+		.map((e) => (e.startsWith("[") ? `:${e.slice(1, e.length - 1)}` : e))
+		.join("/");
+}

package/src/utils/exec.ts

@@ -0,0 +1,24 @@
+/* eslint-disable no-console */
+import { spawn } from "child_process";
+
+export async function exec(
+	program: string,
+	args: string[]
+): Promise<{ stderr: string; stdout: string; exitCode: number }> {
+	return new Promise((resolve, reject) => {
+		let stdout = "";
+		let stderr = "";
+		const process = spawn(program, args);
+		process.stdout.on("data", (data: Buffer) => (stdout += data.toString()));
+		process.stderr.on("data", (data: Buffer) => (stderr += data.toString()));
+		process.on("close", (exitCode) => {
+			if (exitCode === 0) {
+				resolve({ stdout, stderr, exitCode });
+			} else {
+				console.error([program, ...args].join(" "));
+				console.error(stderr);
+				reject({ stdout, stderr, exitCode });
+			}
+		});
+	});
+}

package/src/utils/import-path.ts

@@ -0,0 +1,25 @@
+import { relative, dirname } from "path";
+import _locreq from "locreq";
+const locreq = _locreq(__dirname);
+
+export function importPath(
+	project_module_path: string,
+	project_target_path: string
+): string {
+	let result = relative(
+		dirname(locreq.resolve(project_module_path)),
+		locreq.resolve(project_target_path).replace(/.ts$/, "")
+	);
+	if (result[0] != ".") {
+		result = "./" + result;
+	}
+	return result;
+}
+
+export function curryImportPath(
+	project_module_path: string
+): (project_target_path: string) => string {
+	return function (project_target_path: string) {
+		return importPath(project_module_path, project_target_path);
+	};
+}

package/src/utils/question.ts

@@ -0,0 +1,20 @@
+import { createInterface } from "readline";
+
+export async function question(text: string, validator: (answer: string) => boolean) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+	let answer = "";
+	while (answer == "" || !validator(answer)) {
+		// eslint-disable-next-line no-await-in-loop
+		answer = await new Promise((resolve) => rl.question(text, resolve));
+		if (!validator(answer)) {
+			// eslint-disable-next-line no-console
+			console.log("Try again");
+		}
+	}
+
+	rl.close();
+	return answer;
+}

package/src/utils/walk.ts

@@ -0,0 +1,20 @@
+import { promises as fs } from "fs";
+import { resolve } from "path";
+
+export async function walk(dir: string): Promise<string[]> {
+	const entries = await fs.readdir(dir);
+	let ret: string[] = [];
+	for (const entry of entries) {
+		const fullpath = resolve(dir, entry);
+		// eslint-disable-next-line no-await-in-loop
+		const info = await fs.stat(fullpath);
+
+		if (info.isDirectory()) {
+			// eslint-disable-next-line no-await-in-loop
+			ret = [...ret, ...(await walk(fullpath))];
+		} else {
+			ret = [...ret, fullpath];
+		}
+	}
+	return ret;
+}