@sealcode/sealgen 0.11.8 → 0.12.0

package/dist/templates/long-running-process.js

@@ -0,0 +1,63 @@
+import { curryImportPath } from "../utils/import-path.js";
+async function LongRunningProcessTemplate(action_name, newfilefullpath) {
+  const rel = curryImportPath(newfilefullpath);
+  return `import { Context } from "koa";
+import { TempstreamJSX } from "tempstream";
+import { Page } from "@sealcode/sealgen";
+import html from "${rel("src/back/html.js")}";
+import { LongRunningProcess } from "sealious";
+
+export const actionName = "${action_name}";
+
+export default new (class PatroniteAutoImportStatusPage extends Page {
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: Context) {
+		return { canAccess: true, message: "" };
+	}
+
+	public interval = 2000;
+
+	async render(ctx: Context) {
+		const lpr_id = ctx.params.id;
+		const lpr_data = LongRunningProcess.getByID(ctx.$context, lpr_id);
+		const render_script = lpr_data.state !== "error" && lpr_data.state !== "finished";
+		const script = /* HTML */ \`<script>
+			setTimeout(() => {
+				document.location = document.location;
+			}, \${this.interval});
+		</script>\`;
+
+		return html(
+			ctx,
+			"PatroniteAutoImportStatus",
+			<div>
+				{lpr_data.then((lpr_data) => {
+					return (
+						<div>
+							<div>status: {lpr_data.state}</div>
+							<div style="height: 20px; width: 100%">
+								<div
+									style="height: 100%; background-color: green; width: {Math.round(
+												lpr_data.progress * 100
+											)}%"
+								></div>
+							</div>
+							<div>
+								{lpr_data.events.map((e) => (
+									<div>{e.message}</div>
+								))}
+							</div>
+							{render_script ? { script } : ""}
+						</div>
+					);
+				})}
+			</div>
+		);
+	}
+})();
+`;
+}
+export {
+  LongRunningProcessTemplate
+};
+//# sourceMappingURL=long-running-process.js.map

package/dist/templates/multiform.js

@@ -0,0 +1,58 @@
+import { curryImportPath } from "../utils/utils.js";
+async function multiformTemplate(action_name, newfilefullpath) {
+  const rel = curryImportPath(newfilefullpath);
+  return `import { Context } from "koa";
+import html from "${rel("src/back/html.js")}";
+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));
+	}
+})();
+`;
+}
+export {
+  multiformTemplate
+};
+//# sourceMappingURL=multiform.js.map

package/dist/templates/page.js

@@ -0,0 +1,26 @@
+import { curryImportPath } from "../utils/import-path.js";
+async function pageTemplate(action_name, newfilefullpath) {
+  const rel = curryImportPath(newfilefullpath);
+  return `import { Context } from "koa";
+import { TempstreamJSX } from "tempstream";
+import { Page } from "@sealcode/sealgen";
+import html from "${rel("src/back/html.js")}";
+
+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}", <div></div>);
+	}
+})();
+`;
+}
+export {
+  pageTemplate
+};
+//# sourceMappingURL=page.js.map

package/dist/templates/post.js

@@ -0,0 +1,25 @@
+async function postTemplate(action_name) {
+  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!" }
+		});
+	}
+})();
+`;
+}
+export {
+  postTemplate
+};
+//# sourceMappingURL=post.js.map

package/dist/templates/redirect.js

@@ -0,0 +1,26 @@
+async function redirectTemplate(action_name) {
+  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");
+		});
+	}
+})();
+`;
+}
+export {
+  redirectTemplate
+};
+//# sourceMappingURL=redirect.js.map

package/dist/templates/route-test.js

@@ -0,0 +1,61 @@
+import { curryImportPath } from "../utils/import-path.js";
+function testTemplate(action_name, new_file_fullpath) {
+  const rel = curryImportPath(new_file_fullpath);
+  return `import { withProdApp } from "${rel(
+    "src/back/test_utils/with-prod-app.js"
+  )}";
+import { VERY_LONG_TEST_TIMEOUT, webhintURL } from "${rel(
+    "src/back/test_utils/webhint.js"
+  )}";
+import { ${action_name}URL } from "${rel("src/back/routes/urls.js")}";
+import { getBrowser } from "${rel("src/back/test_utils/browser-creator.js")}";
+import { Browser, BrowserContext, Page } from "@playwright/test";
+
+describe("${action_name} webhint", () => {
+	it(
+		"doesn't crash",
+		async function () {
+			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);
+			});
+		},
+		VERY_LONG_TEST_TIMEOUT
+	);
+});
+
+describe("${action_name}", () => {
+	let page: Page;
+	let browser: Browser;
+	let context: BrowserContext;
+
+	beforeEach(async () => {
+		browser = await getBrowser();
+		context = await browser.newContext();
+		page = await context.newPage();
+	});
+
+	afterEach(async () => {
+		await context.close();
+	});
+
+	it(
+		"works as expected",
+		async function () {
+			return withProdApp(async ({ base_url }) => {
+				await page.goto(base_url + ${action_name}URL);
+			});
+		},
+		VERY_LONG_TEST_TIMEOUT
+	);
+});
+`;
+}
+export {
+  testTemplate
+};
+//# sourceMappingURL=route-test.js.map

package/dist/templates/stateful-page.js

@@ -0,0 +1,69 @@
+import { curryImportPath } from "../utils/import-path.js";
+async function statefulPageTemplate(action_name, newfilefullpath) {
+  const rel = curryImportPath(newfilefullpath);
+  return `import { TempstreamJSX, Templatable } from "tempstream";
+import { BaseContext } from "koa";
+import { StatefulPage } from "@sealcode/sealgen";
+import html from "${rel("src/back/html.js")}";
+
+export const actionName = "${action_name}";
+
+const actions = {
+	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),
+		};
+	},
+} as const;
+
+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 (
+			<div>
+				<ul>
+					{state.elements.map((e, index) => (
+						<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>
+			</div>
+		);
+	}
+})();
+`;
+}
+export {
+  statefulPageTemplate
+};
+//# sourceMappingURL=stateful-page.js.map

package/dist/templates/templates.js

@@ -0,0 +1,24 @@
+import { formTemplate } from "./form.js";
+import { jddComponentTemplate } from "./jdd-component.js";
+import { listTemplate } from "./list.js";
+import { LongRunningProcessTemplate } from "./long-running-process.js";
+import { multiformTemplate } from "./multiform.js";
+import { pageTemplate } from "./page.js";
+import { postTemplate } from "./post.js";
+import { redirectTemplate } from "./redirect.js";
+import { statefulPageTemplate } from "./stateful-page.js";
+const Templates = {
+  page: pageTemplate,
+  form: formTemplate,
+  list: listTemplate,
+  multiform: multiformTemplate,
+  redirect: redirectTemplate,
+  post: postTemplate,
+  sreact: statefulPageTemplate,
+  lpr: LongRunningProcessTemplate,
+  jdd: jddComponentTemplate
+};
+export {
+  Templates
+};
+//# sourceMappingURL=templates.js.map

package/dist/test_utils/locator_is_visible.js

@@ -0,0 +1,14 @@
+import { sleep } from "../utils/sleep.js";
+async function locator_is_visible(locator, timeout = 500) {
+  let exists = false;
+  while (timeout > 0 && !exists) {
+    await sleep(50);
+    timeout -= 50;
+    exists = await locator.isVisible();
+  }
+  return exists;
+}
+export {
+  locator_is_visible
+};
+//# sourceMappingURL=locator_is_visible.js.map

package/dist/utils/assert-throws.js

@@ -0,0 +1,18 @@
+import assert from "assert";
+async function assertThrowsAsync(fn, error_handler) {
+  let error = null;
+  try {
+    await fn();
+  } catch (e) {
+    error = e;
+  } finally {
+    assert.notStrictEqual(error, null, "It didn't throw");
+    if (error_handler) {
+      await error_handler(error);
+    }
+  }
+}
+export {
+  assertThrowsAsync
+};
+//# sourceMappingURL=assert-throws.js.map

package/dist/utils/base64.js

@@ -0,0 +1,11 @@
+function to_base64(s) {
+  return Buffer.from(s).toString("base64");
+}
+function from_base64(s) {
+  return Buffer.from(s, "base64").toString("utf-8");
+}
+export {
+  from_base64,
+  to_base64
+};
+//# sourceMappingURL=base64.js.map

package/dist/utils/browser-creator.js

@@ -0,0 +1,11 @@
+import { firefox } from "playwright";
+let browser_promise = null;
+async function getBrowser() {
+  if (!browser_promise)
+    browser_promise = firefox.launch();
+  return browser_promise;
+}
+export {
+  getBrowser
+};
+//# sourceMappingURL=browser-creator.js.map

package/dist/utils/escape-url-params.js

@@ -0,0 +1,11 @@
+function escape_url_params(url) {
+  return url.split("/").map((e) => e.startsWith(":") ? `[${e.slice(1)}]` : e).filter((e) => e != "").join("/");
+}
+function unescape_url_params(url) {
+  return url.split("/").map((e) => e.startsWith("[") ? `:${e.slice(1, e.length - 1)}` : e).join("/");
+}
+export {
+  escape_url_params,
+  unescape_url_params
+};
+//# sourceMappingURL=escape-url-params.js.map

package/dist/utils/exec.js

@@ -0,0 +1,29 @@
+import { spawn } from "child_process";
+async function exec(program, args) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const process = spawn(program, args);
+    process.stdout.on(
+      "data",
+      (data) => stdout += data.toString()
+    );
+    process.stderr.on(
+      "data",
+      (data) => 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 });
+      }
+    });
+  });
+}
+export {
+  exec
+};
+//# sourceMappingURL=exec.js.map

package/dist/utils/extract-fields-from-collection.js

@@ -0,0 +1,33 @@
+import _locreq from "locreq";
+import { curryImportPath, exec } from "./utils.js";
+const target_locreq = _locreq(process.cwd());
+import { promises as fs } from "fs";
+async function extract_fields_from_collection(collection_name) {
+  const rel = curryImportPath(target_locreq.resolve("dist/back"));
+  const extractor_code = `import {default as Collection} from "${rel(
+    `./back/collections/${collection_name}.js`
+  )}";
+const c = new Collection();
+const fields = [];
+for (const field_name in c.fields){
+    const field = c.fields[field_name];
+    let type = field.typeName;
+    if(["derived-value", "cached-value"].includes(type)){
+	type = field.virtual_field.typeName
+    }
+    fields.push({name: field_name, type})
+}
+console.log(JSON.stringify(fields));
+`;
+  const extractor_code_path = target_locreq.resolve(
+    "dist/back/___extract_fields.js"
+  );
+  await fs.writeFile(extractor_code_path, extractor_code);
+  const { stdout } = await exec("node", [extractor_code_path]);
+  await fs.unlink(extractor_code_path);
+  return JSON.parse(stdout);
+}
+export {
+  extract_fields_from_collection as default
+};
+//# sourceMappingURL=extract-fields-from-collection.js.map

package/dist/utils/format-external-url.js

@@ -0,0 +1,11 @@
+function formatExternalURL(url) {
+  const trimmed = url.trim();
+  if (!trimmed.toLowerCase().startsWith("https://") || !trimmed.toLowerCase().startsWith("https://")) {
+    return `http://${trimmed}`;
+  }
+  return trimmed;
+}
+export {
+  formatExternalURL
+};
+//# sourceMappingURL=format-external-url.js.map

package/dist/utils/import-path.js

@@ -0,0 +1,23 @@
+import { relative, dirname } from "path";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+function importPath(project_module_path, project_target_path) {
+  let result = relative(
+    dirname(target_locreq.resolve(project_module_path)),
+    target_locreq.resolve(project_target_path).replace(/.tsx?$/, ".js")
+  );
+  if (result[0] != ".") {
+    result = "./" + result;
+  }
+  return result;
+}
+function curryImportPath(project_module_path) {
+  return function(project_target_path) {
+    return importPath(project_module_path, project_target_path);
+  };
+}
+export {
+  curryImportPath,
+  importPath
+};
+//# sourceMappingURL=import-path.js.map

package/dist/utils/input-wrapper.js

@@ -0,0 +1,19 @@
+import { tempstream } from "tempstream";
+function getRequiredClass(isRequired) {
+  return isRequired ? "required" : "";
+}
+function getModifierClasses(modifiers) {
+  return modifiers.map((m) => "form-input__wrapper--" + m).join(" ");
+}
+function inputWrapper(modifiers, input) {
+  return tempstream`<div
+		class="form-input form-input__wrapper ${getModifierClasses(modifiers)}"
+	>
+		${input}
+	</div>`;
+}
+export {
+  getRequiredClass,
+  inputWrapper
+};
+//# sourceMappingURL=input-wrapper.js.map

package/dist/utils/list-collections.js

@@ -0,0 +1,13 @@
+import _locreq from "locreq";
+import { walkDir } from "./walk.js";
+const target_locreq = _locreq(process.cwd());
+async function listCollections() {
+  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 !== "");
+}
+export {
+  listCollections
+};
+//# sourceMappingURL=list-collections.js.map

package/dist/utils/make-slug.js

@@ -0,0 +1,7 @@
+function makeSlug(t) {
+  return t.replaceAll(/\P{General_Category=Letter}/g, "-").replaceAll(/-+/g, "-");
+}
+export {
+  makeSlug
+};
+//# sourceMappingURL=make-slug.js.map

package/dist/utils/natural-numbers.js

@@ -0,0 +1,9 @@
+function* naturalNumbers(min, max) {
+  for (let i = min; i <= max; i++) {
+    yield i;
+  }
+}
+export {
+  naturalNumbers
+};
+//# sourceMappingURL=natural-numbers.js.map

package/dist/utils/prettier.js

@@ -0,0 +1,15 @@
+import Prettier from "prettier";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+async function getPrettierConfig() {
+  return {
+    ...await Prettier.resolveConfig(
+      target_locreq.resolve("src/back/routes")
+    ),
+    parser: "typescript"
+  };
+}
+export {
+  getPrettierConfig
+};
+//# sourceMappingURL=prettier.js.map

package/dist/utils/question.js

@@ -0,0 +1,20 @@
+import { createInterface } from "readline";
+async function question(text, validator) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  let answer = "";
+  while (answer == "" || !validator(answer)) {
+    answer = await new Promise((resolve) => rl.question(text, resolve));
+    if (!validator(answer)) {
+      console.log("Try again");
+    }
+  }
+  rl.close();
+  return answer;
+}
+export {
+  question
+};
+//# sourceMappingURL=question.js.map

package/dist/utils/render-attributes.js

@@ -0,0 +1,18 @@
+import { attribute } from "../sanitize.js";
+function renderAttributes(attrs) {
+  return Object.entries(attrs).map(([key, value]) => {
+    if (typeof value === "boolean") {
+      if (value) {
+        return key;
+      } else {
+        return "";
+      }
+    } else {
+      return `${key}="${attribute(value)}"`;
+    }
+  }).join(" ");
+}
+export {
+  renderAttributes
+};
+//# sourceMappingURL=render-attributes.js.map

package/dist/utils/sleep.js

@@ -0,0 +1,7 @@
+async function sleep(time) {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+export {
+  sleep
+};
+//# sourceMappingURL=sleep.js.map

package/dist/utils/translate.js

@@ -0,0 +1,12 @@
+function t(ctx, key, props, default_translation) {
+  return (
+    /* HTML */
+    `<span translation-key="${key.replace('"', '\\"')}"
+		>${ctx.$app.getString(key, props, default_translation)}</span
+	>`
+  );
+}
+export {
+  t
+};
+//# sourceMappingURL=translate.js.map

package/dist/utils/url-with-new-params.js

@@ -0,0 +1,8 @@
+import qs from "qs";
+function UrlWithNewParams(ctx, query_params) {
+  return `${ctx.path}?${qs.stringify(query_params)}`;
+}
+export {
+  UrlWithNewParams
+};
+//# sourceMappingURL=url-with-new-params.js.map