@sealcode/sealgen 0.8.43 → 0.8.47

package/package.json

@@ -1,14 +1,17 @@
 {
 	"name": "@sealcode/sealgen",
-	"version": "0.8.43",
+	"version": "0.8.47",
 	"description": "Module to automate adding routes and collections to a sealious application",
 	"main": "lib/index.js",
 	"scripts": {
-		"test": "node test.js",
+		"test": "mocha",
 		"build": "tsc",
 		"prepare": "npm run build",
 		"watch": "npm run build -- --watch",
-		"test-reports": "npm run build && rm -fr .xunit coverage && npm run test -- --cover --test-report"
+		"clean-coverage": "rm -rf coverage .nyc_output .xunit",
+		"coverage": "npm run clean-coverage && nyc mocha",
+		"test-reports": "npm run clean-coverage && nyc --reporter clover mocha --reporter xunit --reporter-option output=.xunit",
+		"coverage-html": "npm run test-reports && nyc report --reporter lcov && xdg-open coverage/lcov-report/index.html"
 	},
 	"bin": {
 		"sealgen": "./lib/cli.js"
@@ -16,6 +19,8 @@
 	"author": "",
 	"license": "ISC",
 	"devDependencies": {
+		"@istanbuljs/nyc-config-typescript": "^1.0.2",
+		"@playwright/test": "^1.30.0",
 		"@types/koa__router": "^12.0.0",
 		"@types/mocha": "^9.0.0",
 		"@types/node": "^18.11.4",
@@ -27,13 +32,16 @@
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-prettier": "^3.4.1",
 		"eslint-plugin-with-tsc-error": "^0.0.7",
+		"get-port": "^5.0.0",
 		"koa-body": "^5.0.0",
-		"mocha": "^9.1.1",
-		"mri": "^1.1.6",
+		"mocha": "^9.2.2",
+		"mri": "^1.2.0",
 		"nyc": "^15.1.0",
-		"source-map-support": "^0.5.19",
-		"ts-node": "^10.2.1",
-		"typescript": "^4.3.5"
+		"playwright": "^1.29.2",
+		"source-map-support": "^0.5.21",
+		"ts-node": "^10.9.1",
+		"typescript": "^4.3.5",
+		"wait-port": "^1.0.4"
 	},
 	"types": "./@types/index.d.ts",
 	"dependencies": {

package/src/add-route.test.ts

@@ -0,0 +1,58 @@
+import { promises as fs } from "fs";
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import axios from "axios";
+import waitPort from "wait-port";
+import getPort from "get-port";
+
+const execAsync = promisify(exec);
+
+describe("add route test", () => {
+	let node_pid = 0;
+	const app_path = "/tmp/sealious-minimal";
+	const container_name = "sealgen-test-mongo";
+	afterEach(async function () {
+		if (node_pid != 0) await execAsync(`kill -9 ${node_pid}`);
+		await Promise.all([
+			fs.rm(app_path, { recursive: true, force: true }),
+			execAsync(`docker rm -f ${container_name}`),
+		]);
+	});
+
+	it("creates minimal sealious app", async function () {
+		this.timeout(250000);
+		console.log("\tcloning sealious-minimal...");
+		await execAsync(
+			`git clone https://hub.sealcode.org/source/sealious-minimal.git ${app_path} && cd ${app_path} && git checkout f48991a0a8b426e0d2f4a4b448fdd41d643b0dae`
+		);
+		console.log("\tinstalling dependencies and sealgen...");
+		await execAsync(
+			`cd ${app_path} && npm ci && rm -rf node_modules/@sealcode/sealgen && ln -s $OLDPWD node_modules/@sealcode/sealgen`
+		);
+		console.log("\trunning add-route and building app...");
+		await execAsync(
+			`cd ${app_path} && npx sealgen add-route --url=/sample --action=Sample --mode=page && npm run build`
+		);
+		console.log(
+			"\tstarting the database...(if timeouts here, run 'docker pull mongo:4.4-bionic' to solve)"
+		);
+		const port = await getPort();
+		await execAsync(`docker run -p ${port}:27017 --name ${container_name} -d mongo:4.4-bionic`);
+		console.log("\trunning app and making request to the generated url...");
+		const env = { ...process.env, SEALIOUS_MONGO_PORT: port.toString() };
+		let app_start = spawn(`node`, [`${app_path}/dist/back/index.js`], {
+			env,
+		});
+		if (app_start.pid == undefined) throw new Error("node failed to start");
+		node_pid = app_start.pid;
+		await waitPort({
+			host: "localhost",
+			port: 8080,
+			output: "silent",
+			timeout: 6000,
+		});
+		const res = await axios.get("http://localhost:8080/sample");
+		if (res.status != 200)
+			throw new Error("url generated by add-route exists but doesnt return 200");
+	});
+});

package/src/add-route.ts

@@ -9,14 +9,15 @@ import { pageTemplate } from "./templates/page";
 import { redirectTemplate } from "./templates/redirect";
 import { testTemplate } from "./templates/route-test";
 import { escape_url_params } from "./utils/escape-url-params";
-import { question } from "./utils/question";
 import prompts = require("prompts");
 import { postTemplate } from "./templates/post";
 
-const target_locreq = _locreq(process.cwd());
-
-export async function addRoute(): Promise<void> {
-	prompts.override(require("yargs").argv);
+export async function addRoute(
+	params: Partial<{ [key in "action" | "url" | "mode"]: string }>,
+	app_directory: string = process.cwd()
+): Promise<void> {
+	const target_locreq = _locreq(app_directory);
+	prompts.override(params);
 	const response = await prompts([
 		{
 			type: "text",

package/src/build.ts

@@ -31,6 +31,7 @@ async function complex_build(watch: boolean): Promise<void> {
 		const watcher = chokidar.watch("src", { ignoreInitial: true });
 		watcher.on("all", async (_, path) => {
 			if (!scss_build) return;
+			if (path.includes(".#")) return;
 			if (path.endsWith(".scss") && !path.endsWith("/includes.scss")) {
 				// refresh the list of all scss files in includes.scss
 				await generateScssIncludes();
@@ -70,9 +71,11 @@ async function complex_build(watch: boolean): Promise<void> {
 	watch && scss_build?.rebuild?.();
 }
 
-export async function buildProject(...args: string[]): Promise<void> {
-	const watch = args.includes("--watch");
-
+export async function buildProject({
+	watch,
+}: {
+	watch: boolean;
+}): Promise<void> {
 	try {
 		await build({
 			entryPoints: ["./src/front/index.ts"],

package/src/cli.ts

@@ -9,7 +9,7 @@ import { makeEnv } from "./make-env";
 
 const actions: Record<
 	string,
-	(...args: string[]) => Promise<void> | undefined
+	(args: Record<string, string | boolean>) => Promise<void> | undefined
 > = {
 	"add-collection": addCollection,
 	"add-route": addRoute,
@@ -32,5 +32,5 @@ void (async function () {
 	const action = process.argv.at(2);
 	actions;
 	const fn = actions[action || "default"] || actions.default;
-	await fn(...process.argv.slice(3));
+	await fn(require("yargs").argv);
 })();

package/src/forms/fields/boolean.test.ts

@@ -0,0 +1,36 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("boolean field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const required = new Fields.Boolean(true);
+		const not_required = new Fields.Boolean(false);
+
+		assert.strictEqual((await required.isValueValid(ctx, true)).valid, true);
+		assert.strictEqual((await required.isValueValid(ctx, false)).valid, false);
+		assert.strictEqual((await not_required.isValueValid(ctx, true)).valid, true);
+		assert.strictEqual((await not_required.isValueValid(ctx, false)).valid, true);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.Boolean(true);
+		const true_response = await field.parse(ctx, true as any);
+		const null_response = await field.parse(ctx, null as any);
+		const true_as_string_response = await field.parse(ctx, "true");
+		const undefined_response = await field.parse(ctx, undefined);
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(true_response.parsable, true);
+		assert.strictEqual(true_response.parsed_value, true);
+		assert.strictEqual(null_response.parsable, true);
+		assert.strictEqual(null_response.parsed_value, false);
+		assert.strictEqual(true_as_string_response.parsable, true);
+		assert.strictEqual(true_as_string_response.parsed_value, true);
+		assert.strictEqual(undefined_response.parsable, true);
+		assert.strictEqual(undefined_response.parsed_value, false);
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a boolean");
+	});
+});

package/src/forms/fields/email.test.ts

@@ -0,0 +1,24 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("email field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.EmailField(true);
+
+		assert.strictEqual((await field.isValueValid(ctx, "yes@an.email")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notanemail")).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.EmailField(true);
+		const string_response = await field.parse(ctx, "42");
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(string_response.parsable, true);
+		assert.strictEqual(string_response.parsed_value, "42");
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a string");
+	});
+});

package/src/forms/fields/enum-multiple.test.ts

@@ -0,0 +1,31 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("enum-multiple field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.EnumMultipleField(true, ["sa", "mp", "le"]);
+
+		assert.strictEqual((await field.isValueValid(ctx, ["sa", "le"])).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, ["notvalid"])).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, [42] as any)).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.EnumMultipleField(true, []);
+		const string_array_response = await field.parse(ctx, ["42"]);
+		const number_response = await field.parse(ctx, 42);
+		const string_response = await field.parse(ctx, "sample");
+		const null_response = await field.parse(ctx, null as any);
+
+		assert.strictEqual(string_array_response.parsable, true);
+		assert.deepEqual(string_array_response.parsed_value, ["42"]);
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a list of strings");
+		assert.strictEqual(string_response.parsable, true);
+		assert.deepEqual(string_response.parsed_value, ["sample"]);
+		assert.strictEqual(null_response.parsable, true);
+		assert.deepEqual(null_response.parsed_value, []);
+	});
+});

package/src/forms/fields/enum.test.ts

@@ -0,0 +1,25 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("enum field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.EnumField(true, ["sa", "mp", "le"]);
+
+		assert.strictEqual((await field.isValueValid(ctx, 42)).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, "mp")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.EnumField(true, []);
+		const string_response = await field.parse(ctx, "42");
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(string_response.parsable, true);
+		assert.strictEqual(string_response.parsed_value, "42");
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a string");
+	});
+});

package/src/forms/fields/number.test.ts

@@ -0,0 +1,34 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("number field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const required = new Fields.NumberField(true, 0);
+		const not_required = new Fields.NumberField(false, 0);
+
+		assert.strictEqual((await required.isValueValid(ctx, 42)).valid, true);
+		assert.strictEqual((await required.isValueValid(ctx, "42")).valid, true);
+		assert.strictEqual((await required.isValueValid(ctx, "notvalid")).valid, false);
+		assert.strictEqual((await not_required.isValueValid(ctx, "")).valid, true);
+	});
+
+	it("parse function", async () => {
+		const required = new Fields.NumberField(true, 0);
+		const decimal_digits = new Fields.NumberField(true, 0, { decimalDigits: 1 });
+		const number_as_string_response = await required.parse(ctx, "42");
+		const number_response = await required.parse(ctx, 42);
+		const not_a_number_response = await required.parse(ctx, "notanumber");
+		const decimal_number_response = await decimal_digits.parse(ctx, 42.42);
+
+		assert.strictEqual(number_as_string_response.parsable, true);
+		assert.strictEqual(number_as_string_response.parsed_value, 42);
+		assert.strictEqual(number_response.parsable, true);
+		assert.strictEqual(number_response.parsed_value, 42);
+		assert.strictEqual(not_a_number_response.parsable, false);
+		assert.strictEqual(not_a_number_response.error, "Please enter a number");
+		assert.strictEqual(decimal_number_response.parsable, true);
+		assert.strictEqual(decimal_number_response.parsed_value, 42.4);
+	});
+});

package/src/forms/fields/number.ts

@@ -44,7 +44,6 @@ export class NumberField<
 				parseFloat(value).toString() == value.trim()) ||
 			is(value, predicates.number)
 		) {
-			console.log(this.name, this.options.decimalDigits);
 			return {
 				parsable: true,
 				parsed_value: this.options.decimalDigits

package/src/forms/fields/pick-from-list.test.ts

@@ -0,0 +1,19 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("pick-from-list field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.PickFromListField(true, async () => {
+			return [
+				{ value: "samplev", label: "samplel" },
+				{ value: "samplevv", label: "samplell" },
+			];
+		});
+
+		assert.strictEqual((await field.isValueValid(ctx, 42 as any)).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, "samplevv")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+	});
+});

package/src/forms/fields/regexp.test.ts

@@ -0,0 +1,25 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("regexp field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.RegExpField(true, /^4/, "error");
+
+		assert.strictEqual((await field.isValueValid(ctx, "42")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, 42)).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.RegExpField(true, /^4/, "error");
+		const string_response = await field.parse(ctx, "42");
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(string_response.parsable, true);
+		assert.strictEqual(string_response.parsed_value, "42");
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a string");
+	});
+});