@sealcode/sealgen 0.8.48 → 0.8.49

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,60 @@
+import { curryImportPath } from "../utils/import-path";
+
+export async function formTemplate(
+	action_name: string,
+	newfilefullpath: string
+): Promise<string> {
+	const rel = curryImportPath(newfilefullpath);
+	return `import { Context } from "koa";
+import { Form, FormData, FormDataValue, Fields, Controls } from "@sealcode/sealgen";
+import html from "${rel("src/back/html")}";
+import { Users } from "${rel("src/back/collections/collections")}";
+
+export const actionName = "${action_name}";
+
+const fields = {
+	email: new Fields.CollectionField(true, Users.fields.email),
+	password: new Fields.SimpleFormField(true),
+};
+
+export const ${action_name}Shape = Fields.fieldsToShape(fields);
+
+export default new (class ${action_name}Form extends Form<typeof fields, void> {
+	defaultSuccessMessage = "Formularz wypełniony poprawnie";
+	fields = fields;
+
+	controls = [
+		new Controls.SimpleInput(fields.email, { label: "Email:", type: "email" }),
+		new Controls.SimpleInput(fields.password, { label: "Password:", type: "password" }),
+	];
+
+	async validateValues(
+		ctx: Context,
+		data: Record<string, FormDataValue>
+	): Promise<{ valid: boolean; error: string }> {
+		// just an example
+		const { parsed: email } = await this.fields.email.getValue(ctx, data);
+		const { parsed: password } = await this.fields.password.getValue(ctx, data);
+		if ((password || "").length > (email || "").length) {
+			return { valid: false, error: "Password cannot be longer than email" };
+		} else {
+			return { valid: true, error: "" };
+		}
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: Context) {
+		return { canAccess: true, message: "" };
+	}
+
+	async onSubmit() {
+		//noop
+		return;
+	}
+
+	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
+		return html(ctx, "${action_name}", await super.render(ctx, data, show_field_errors));
+	}
+})();
+`;
+}

package/src/templates/list.ts

@@ -0,0 +1,75 @@
+import { curryImportPath } from "../utils/import-path";
+import prompts = require("prompts");
+import { listCollections } from "../utils/list-collections";
+
+export const listTemplate = async (
+	action_name: string,
+	newfilefullpath: string
+): Promise<string> => {
+	const response = await prompts({
+		type: "autocomplete",
+		name: "collection",
+		message: "Which sealious collection do you want to list?",
+		choices: (
+			await listCollections()
+		).map((collection) => ({
+			title: collection,
+			value: collection,
+		})),
+	});
+	const collection = response.collection as string;
+	const uppercase_collection =
+		collection[0].toLocaleUpperCase() + collection.slice(1);
+	const rel = curryImportPath(newfilefullpath);
+	return `import { Context } from "koa";
+import { CollectionItem } from "sealious";
+import { tempstream } from "tempstream";
+import { ${uppercase_collection} } from "${rel(
+		"src/back/collections/collections"
+	)}";
+import html from "${rel("src/back/html.ts")}";
+import { SealiousItemListPage, BaseListPageFields } from "@sealcode/sealgen";
+
+export const actionName = "${action_name}";
+
+const filterFields = {};
+
+export default new (class ${action_name}Page extends SealiousItemListPage<
+	typeof ${uppercase_collection},
+	typeof BaseListPageFields
+> {
+	fields = BaseListPageFields;
+
+	filterFields = filterFields;
+	filterControls = [];
+
+	async render(ctx: Context) {
+		return html(
+			ctx,
+			"${uppercase_collection}",
+			tempstream/* HTML */ \`<div>
+				<h2>${uppercase_collection} List</h2>
+				<table>
+					<thead>
+						<th>id</th>
+						\${Object.keys(${uppercase_collection}.fields).map(
+							(fieldname) => \`<th>\${fieldname}</th>\`
+						)}
+					</thead>
+					<tbody>
+						\${super.render(ctx)}
+					</tbody>
+				</table>
+			</div>\`
+		);
+	}
+
+	async renderItem(_: Context, item: CollectionItem<typeof ${uppercase_collection}>) {
+		return tempstream\`<tr><td>\${item.id}</td>\${Object.keys(${uppercase_collection}.fields).map(
+			(fieldname: keyof typeof ${uppercase_collection}["fields"]) =>
+				tempstream\`<td>\${item.get(fieldname)}</td>\`
+		)}</tr>\`;
+	}
+})(${uppercase_collection});
+`;
+};

package/src/templates/multiform.ts

@@ -0,0 +1,58 @@
+import { curryImportPath } from "../utils/utils";
+
+export async function multiformTemplate(
+	action_name: string,
+	newfilefullpath: string
+): Promise<string> {
+	const rel = curryImportPath(newfilefullpath);
+	return `import { Context } from "koa";
+import html from "${rel("src/back/html")}";
+import { Controls, Fields, Form, FormMessage, Multiform } from "@sealcode/sealgen";
+import { FlatTemplatable } from "tempstream";
+
+export const actionName = "${action_name}";
+
+const fields1 = {
+	email: new Fields.SimpleFormField(true),
+	password: new Fields.SimpleFormField(true),
+};
+
+const form1 = new (class extends Form<typeof fields1> {
+	defaultSuccessMessage = "Form1 done!";
+	controls = [
+		new Controls.FormHeader("form1"),
+		new Controls.SimpleInput(fields1.email),
+	];
+	fields = fields1;
+	onSubmit() {
+		console.log("form1 submit");
+	}
+})();
+
+const fields2 = {
+	name: new Fields.SimpleFormField(true),
+	surname: new Fields.SimpleFormField(true),
+};
+
+const form2 = new (class extends Form<Record<never, unknown>> {
+	defaultSuccessMessage = "Form2 done!";
+	controls = [new Controls.FormHeader("form2"), new Controls.SimpleInput(fields2.name)];
+	fields = fields2;
+	onSubmit() {
+		console.log("form2 submit");
+	}
+})();
+
+export default new (class extends Multiform {
+	name = "multiform_test";
+	forms = { form1, form2 };
+	async render(
+		ctx: Context,
+		messages: FormMessage[],
+		prerenderedForms?: Record<string, FlatTemplatable | undefined>
+	): Promise<FlatTemplatable> {
+		return html(ctx, "${action_name}", await super.render(ctx, messages, prerenderedForms));
+	}
+})();
+`;
+}

package/src/templates/page.ts

@@ -0,0 +1,25 @@
+import { curryImportPath } from "../utils/import-path";
+export async function pageTemplate(
+	action_name: string,
+	newfilefullpath: string
+): Promise<string> {
+	const rel = curryImportPath(newfilefullpath);
+	return `import { Context } from "koa";
+import { tempstream } from "tempstream";
+import { Page } from "@sealcode/sealgen";
+import html from "${rel("src/back/html")}";
+
+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(_: Context) {
+		return { canAccess: true, message: "" };
+	}
+
+	async render(ctx: Context) {
+		return html(ctx, "${action_name}", tempstream/* HTML */ \`<div></div>\`);
+	}
+})();
+`;
+}

package/src/templates/post.ts

@@ -0,0 +1,21 @@
+export async function postTemplate(action_name: string): Promise<string> {
+	return `import { Context } from "koa";
+import { Mountable } from "@sealcode/sealgen";
+import Router from "@koa/router";
+
+export const actionName = "${action_name}";
+
+export default new (class ${action_name}Redirect extends Mountable {
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: Context) {
+		return { canAccess: true, message: "" };
+	}
+
+	mount(router: Router, path: string) {
+		router.post(path, async (ctx) => {
+			ctx.body = { message: "OK!" }
+		});
+	}
+})();
+`;
+}

package/src/templates/redirect.ts

@@ -0,0 +1,22 @@
+export async function redirectTemplate(action_name: string): Promise<string> {
+	return `import { Context } from "koa";
+import { Mountable } from "@sealcode/sealgen";
+import Router from "@koa/router";
+
+export const actionName = "${action_name}";
+
+export default new (class ${action_name}Redirect extends Mountable {
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: Context) {
+		return { canAccess: true, message: "" };
+	}
+
+	mount(router: Router, path: string) {
+		router.get(path, async (ctx) => {
+			ctx.status = 302;
+			ctx.redirect("/new_url");
+		});
+	}
+})();
+`;
+}

package/src/templates/route-test.ts

@@ -0,0 +1,27 @@
+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/urls")}";
+
+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/templates/stateful-page.ts

@@ -0,0 +1,65 @@
+import { curryImportPath } from "../utils/import-path";
+
+export async function statefulPageTemplate(
+	action_name: string,
+	newfilefullpath: string
+): Promise<string> {
+	const rel = curryImportPath(newfilefullpath);
+	return `import { BaseContext } from "koa";
+import { tempstream, Templatable } from "tempstream";
+import { StatefulPage } from "@sealcode/sealgen";
+import html from "${rel("src/back/html")}";
+
+export const actionName = "${action_name}";
+
+const actions = <const>{
+	add: (state: State, inputs: Record<string, string>) => {
+		console.log({ inputs });
+		return {
+			...state,
+			elements: [...state.elements, inputs.element_to_add || "new element"],
+		};
+	},
+	remove: (state: State, _: unknown, index_to_remove: number) => {
+		return {
+			...state,
+			elements: state.elements.filter((_, index) => index != index_to_remove),
+		};
+	},
+};
+
+type State = {
+	elements: string[];
+};
+
+	export default new (class ${action_name}Page extends StatefulPage<State, typeof actions> {
+	actions = actions;
+
+	getInitialState() {
+		return { elements: ["one", "two", "three"] };
+	}
+
+    wrapInLayout(ctx: BaseContext, content: Templatable): Templatable {
+		return html(ctx, "${action_name}", content);
+	}
+
+	render(ctx: BaseContext, state: State, inputs: Record<string, string>) {
+		return tempstream/* HTML */ \`<ul>
+				\${state.elements.map(
+					(e, index) => /* HTML */ \`<li>
+						\${e} \${this.makeActionButton(state, "remove", index)}
+					</li>\`
+				)}
+			</ul>
+			<div>
+				<input
+						name="element_to_add"
+						type="text"
+						value="\${inputs.element_to_add || ""}"
+					/>
+					\${this.makeActionButton(state, "add")}
+			</div>\`;
+	}
+})();
+`;
+}

package/src/test_utils/locator_is_visible.ts

@@ -0,0 +1,17 @@
+/* eslint-disable no-await-in-loop */
+import { Locator } from "playwright";
+import { sleep } from "../utils/sleep";
+
+export async function locator_is_visible(
+	locator: Locator,
+	timeout = 500
+): Promise<boolean> {
+	let exists = false;
+	while (timeout > 0 && !exists) {
+		await sleep(50);
+		timeout -= 50;
+		exists = await locator.isVisible();
+	}
+
+	return exists;
+}

package/src/utils/assert-throws.ts

@@ -0,0 +1,18 @@
+import assert from "assert";
+
+export async function assertThrowsAsync(
+	fn: () => Promise<unknown>,
+	error_handler?: (e: unknown) => Promise<void> | void
+): Promise<void> {
+	let error: unknown = null;
+	try {
+		await fn();
+	} catch (e: unknown) {
+		error = e;
+	} finally {
+		assert.notStrictEqual(error, null, "It didn't throw");
+		if (error_handler) {
+			await error_handler(error);
+		}
+	}
+}

package/src/utils/base64.ts

@@ -0,0 +1,7 @@
+export function to_base64(s: string) {
+	return Buffer.from(s).toString("base64");
+}
+
+export function from_base64(s: string) {
+	return Buffer.from(s, "base64").toString("utf-8");
+}

package/src/utils/browser-creator.js

@@ -0,0 +1,10 @@
+import { firefox } from "playwright";
+
+let browser_promise = null;
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export async function getBrowser() {
+	if (!browser_promise) browser_promise = firefox.launch();
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return browser_promise;
+}

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

@@ -0,0 +1,14 @@
+export function escape_url_params(url: string): string {
+	return url
+		.split("/")
+		.map((e) => (e.startsWith(":") ? `[${e.slice(1)}]` : e))
+		.filter((e) => 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,30 @@
+/* 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/format-external-url.ts

@@ -0,0 +1,13 @@
+// this is not an ultra-safe parser. It's meant to help parse urls that users
+// have entered in a simple input file withour validation
+
+export function formatExternalURL(url: string) {
+	const trimmed = url.trim();
+	if (
+		!trimmed.toLowerCase().startsWith("https://") ||
+		!trimmed.toLowerCase().startsWith("https://")
+	) {
+		return `http://${trimmed}`;
+	}
+	return trimmed;
+}

package/src/utils/import-path.ts

@@ -0,0 +1,25 @@
+import { relative, dirname } from "path";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+
+export function importPath(
+	project_module_path: string,
+	project_target_path: string
+): string {
+	let result = relative(
+		dirname(target_locreq.resolve(project_module_path)),
+		target_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/input-wrapper.ts

@@ -0,0 +1,21 @@
+import { Readable } from "stream";
+import { FlatTemplatable, tempstream } from "tempstream";
+
+export function getRequiredClass(isRequired: boolean): string {
+	return isRequired ? "required" : "";
+}
+
+function getModifierClasses(modifiers: string[]) {
+	return modifiers.map((m) => "form-input__wrapper--" + m).join(" ");
+}
+
+export function inputWrapper(
+	modifiers: string[],
+	input: FlatTemplatable
+): Readable {
+	return tempstream/* HTML */ `<div
+		class="form-input form-input__wrapper ${getModifierClasses(modifiers)}"
+	>
+		${input}
+	</div>`;
+}

package/src/utils/list-collections.ts

@@ -0,0 +1,16 @@
+import _locreq from "locreq";
+import { walkDir } from "./walk";
+const target_locreq = _locreq(process.cwd());
+
+export async function listCollections(): Promise<string[]> {
+	const files = await walkDir(target_locreq.resolve("src/back/collections"));
+	return files
+		.filter(
+			(f) =>
+				f.endsWith(".ts") &&
+				!f.endsWith(".test.ts") &&
+				!f.endsWith("collections.ts")
+		)
+		.map((f) => f.replace(/.ts$/, "").split("/").at(-1) || "")
+		.filter((e) => e !== "");
+}

package/src/utils/make-slug.ts

@@ -0,0 +1,5 @@
+export function makeSlug(t: string) {
+	return t
+		.replaceAll(/\P{General_Category=Letter}/g, "-")
+		.replaceAll(/-+/g, "-");
+}

package/src/utils/natural-numbers.ts

@@ -0,0 +1,5 @@
+export function* naturalNumbers(min: number, max: number) {
+	for (let i = min; i <= max; i++) {
+		yield i;
+	}
+}

package/src/utils/prettier.ts

@@ -0,0 +1,13 @@
+import * as prettier from "prettier";
+import { Options } from "prettier";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+
+export async function getPrettierConfig(): Promise<Options> {
+	return {
+		...(await prettier.resolveConfig(
+			target_locreq.resolve("src/back/routes")
+		)),
+		parser: "typescript",
+	};
+}

package/src/utils/question.ts

@@ -0,0 +1,23 @@
+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/render-attributes.ts

@@ -0,0 +1,17 @@
+import { attribute } from "../sanitize";
+
+export function renderAttributes(attrs: Record<string, string | boolean>) {
+	return Object.entries(attrs)
+		.map(([key, value]) => {
+			if (typeof value === "boolean") {
+				if (value) {
+					return key;
+				} else {
+					return "";
+				}
+			} else {
+				return `${key}="${attribute(value)}"`;
+			}
+		})
+		.join(" ");
+}

package/src/utils/sleep.ts

@@ -0,0 +1,3 @@
+export async function sleep(time: number) {
+	return new Promise((resolve) => setTimeout(resolve, time));
+}

package/src/utils/translate.ts

@@ -0,0 +1,13 @@
+import { Context } from "koa";
+import { Translation } from "sealious";
+
+export function t(
+	ctx: Context,
+	key: string,
+	props: any[],
+	default_translation: Translation
+) {
+	return /* HTML */ `<span translation-key="${key.replace('"', '\\"')}"
+		>${ctx.$app.getString(key, props, default_translation)}</span
+	>`;
+}

package/src/utils/url-with-new-params.ts

@@ -0,0 +1,9 @@
+import { Context } from "koa";
+import qs from "qs";
+
+export function UrlWithNewParams(
+	ctx: Context,
+	query_params: Record<string, unknown>
+): string {
+	return `${ctx.path}?${qs.stringify(query_params)}`;
+}