@sealcode/sealgen 0.11.8 → 0.12.2

package/@types/utils/input-wrapper.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { Readable } from "stream";
 import { FlatTemplatable } from "tempstream";
 export declare function getRequiredClass(isRequired: boolean): string;

package/@types/utils/utils.d.ts

@@ -2,15 +2,15 @@ export type Awaited<T> = T extends Promise<infer U> ? U : T;
 export type UnwrapArray<T> = T extends Array<infer U> ? U : T;
 export declare function keys<S extends string>(object: Record<S, unknown>): S[];
 export type ExtractTail<T extends any[]> = T extends [infer _, ...infer Tail] ? Tail : never;
-export { sleep } from "./sleep";
-export { naturalNumbers } from "./natural-numbers";
-export { UrlWithNewParams } from "./url-with-new-params";
-export { exec } from "./exec";
-export { importPath, curryImportPath } from "./import-path";
-export { listCollections } from "./list-collections";
-export { walkDir } from "./walk";
-export { assertThrowsAsync } from "./assert-throws";
-export * from "./make-slug";
-export * from "./render-attributes";
-export * from "./format-external-url";
-export * from "./base64";
+export { sleep } from "./sleep.js";
+export { naturalNumbers } from "./natural-numbers.js";
+export { UrlWithNewParams } from "./url-with-new-params.js";
+export { exec } from "./exec.js";
+export { importPath, curryImportPath } from "./import-path.js";
+export { listCollections } from "./list-collections.js";
+export { walkDir } from "./walk.js";
+export { assertThrowsAsync } from "./assert-throws.js";
+export * from "./make-slug.js";
+export * from "./render-attributes.js";
+export * from "./format-external-url.js";
+export * from "./base64.js";

package/@types/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/build.js

@@ -0,0 +1,18 @@
+import * as esbuild from "esbuild";
+import { default as glob } from "tiny-glob";
+import { remove_named_imports } from "./remove-named-imports.js";
+
+const entryPoints = (await glob("./src/**/*.{js,ts,tsx}")).filter(
+	(path) => !path.includes(".#")
+);
+
+await esbuild.build({
+	entryPoints,
+	sourcemap: true,
+	bundle: false,
+	outdir: "./dist/",
+	logLevel: "info",
+	platform: "node",
+	target: "es2022",
+	format: "esm",
+});

package/dist/add-collection.js

@@ -0,0 +1,31 @@
+import { resolve } from "path";
+import _locreq from "locreq";
+import { promises as fs, existsSync } from "fs";
+import { question } from "./utils/question.js";
+import { collectionTemplate } from "./templates/collection.js";
+import { generateCollections } from "./generate-collections.js";
+const target_locreq = _locreq(process.cwd());
+async function addCollection() {
+  const regex_pattern = /^([A-Z_$][a-zA-Z0-9_$]*)$/;
+  const collection_name = await question(
+    `What's the name of the collection class (e.g. "SecretDocuments", must start with a capital letter): `,
+    (s) => s.length > 3 && regex_pattern.test(s)
+  );
+  const url = await question(
+    "Enter the url-friendly name for the collection (e.g. secret-documents): ",
+    (s) => !s.includes("/") && !s.includes(" ")
+  );
+  const file_path = target_locreq.resolve(`src/back/collections/${url}.ts`);
+  if (existsSync(file_path)) {
+    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));
+  console.log(`${file_path} created`);
+  await generateCollections();
+}
+export {
+  addCollection
+};
+//# sourceMappingURL=add-collection.js.map

package/dist/add-jdd-component.js

@@ -0,0 +1,42 @@
+import { resolve } from "path";
+import _locreq from "locreq";
+import { promises as fs, existsSync } from "fs";
+import { question } from "./utils/question.js";
+const target_locreq = _locreq(process.cwd());
+import { jddComponentTemplate } from "./templates/jdd-component.js";
+import { generateComponents } from "./generate-components.js";
+import { toKebabCase } from "js-convert-case";
+async function addJDDComponent() {
+  const component_name = await question(
+    "What's the name of the component?  > ",
+    (s) => s.length > 3
+  );
+  const file_path = target_locreq.resolve(
+    `src/back/jdd-components/${toKebabCase(component_name)}/${toKebabCase(
+      component_name
+    )}.jdd.tsx`
+  );
+  if (existsSync(file_path)) {
+    console.error(`ERROR: File ${file_path} already exists.`);
+    return;
+  }
+  await fs.mkdir(resolve(file_path, "../"), { recursive: true });
+  await fs.writeFile(file_path, jddComponentTemplate(component_name));
+  const css_file_path = target_locreq.resolve(
+    `src/back/jdd-components/${toKebabCase(component_name)}/${toKebabCase(
+      component_name
+    )}.css`
+  );
+  await fs.writeFile(
+    css_file_path,
+    `.${toKebabCase(component_name)} {
+}`
+  );
+  console.log(`Created ${file_path}`);
+  console.log(`Created ${css_file_path}`);
+  await generateComponents();
+}
+export {
+  addJDDComponent
+};
+//# sourceMappingURL=add-jdd-component.js.map

package/dist/add-route.js

@@ -0,0 +1,67 @@
+import { existsSync, promises as fs } from "fs";
+import _locreq from "locreq";
+import { resolve } from "path";
+import { generateRoutes } from "./generate-routes.js";
+import { testTemplate } from "./templates/route-test.js";
+import { escape_url_params } from "./utils/escape-url-params.js";
+import prompts from "prompts";
+import { Templates } from "./templates/templates.js";
+async function addRoute(params, app_directory = process.cwd()) {
+  const target_locreq = _locreq(app_directory);
+  prompts.override(params);
+  const response = await prompts([
+    {
+      type: "text",
+      name: "action",
+      message: `What's the name of the action (e.g. "AddUser"): `,
+      validate: (s) => s.length > 3 ? true : "Should be at least 3 characters long"
+    },
+    {
+      type: "text",
+      name: "url",
+      message: "Enter a full absolute path for the new route (for example: /admin/users/:id/edit): ",
+      validate: (s) => s.trim()[0] == "/" ? true : "Should start with a '/'"
+    },
+    {
+      type: "select",
+      name: "mode",
+      message: "What kind of route is it?",
+      choices: [
+        { title: "page", value: "page" },
+        { title: "stateful page", value: "sreact" },
+        { title: "form", value: "form" },
+        { title: "list", value: "list" },
+        { title: "multiform", value: "multiform" },
+        { title: "redirect", value: "redirect" },
+        { title: "raw POST", value: "post" },
+        { title: "Long Running Process status page", value: "lpr" }
+      ]
+    }
+  ]);
+  const { action, url, mode } = response;
+  const extension = ["list", "lpr", "page", "sreact"].includes(mode) ? "tsx" : "ts";
+  const file_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}.${mode}.${extension}`
+  );
+  const test_file_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}.test.ts`
+  );
+  const template = Templates[mode];
+  if (!template) {
+    throw new Error(`Could not get template ${mode}`);
+  }
+  if (existsSync(file_path)) {
+    console.error(`ERROR: File ${file_path} already exists.`);
+    return;
+  }
+  await fs.mkdir(resolve(file_path, "../"), { recursive: true });
+  await fs.writeFile(file_path, await template(action, file_path));
+  await fs.writeFile(test_file_path, testTemplate(action, file_path));
+  console.log(`${file_path} created`);
+  console.log(`${test_file_path} created`);
+  await generateRoutes();
+}
+export {
+  addRoute
+};
+//# sourceMappingURL=add-route.js.map

package/dist/add-route.test.js

@@ -0,0 +1,90 @@
+import { promises as fs } from "fs";
+import { exec, spawn } from "child_process";
+import axios from "axios";
+import waitPort from "wait-port";
+import getPort from "get-port";
+import _locreq from "locreq";
+const locreq = _locreq(__dirname);
+const execAsync = (cmd) => {
+  return new Promise((resolve, reject) => {
+    const process2 = exec(cmd);
+    console.log("EXECUTING", cmd);
+    process2?.stdout?.on("data", (data) => {
+      console.log(`stdout: ${data}`);
+    });
+    process2?.stderr?.on("data", (data) => {
+      console.log(`stdout: ${data}`);
+    });
+    process2.on("exit", (code) => {
+      if (code == 0) {
+        resolve();
+      } else {
+        reject();
+      }
+    });
+  });
+};
+const callSealgenBin = () => `node ${locreq.resolve("dist/cli.js")}`;
+describe("add route test", () => {
+  let node_pid = 0;
+  const timestamp = Date.now();
+  const app_path = `/tmp/sealious-minimal-${timestamp}`;
+  const container_name = `sealgen-test-mongo-${timestamp}`;
+  afterEach(async function() {
+    try {
+      if (node_pid != 0)
+        await execAsync(`kill -9 ${node_pid}`);
+    } catch (error) {
+      throw new Error("node process exited unexpectedly, please inspect the output");
+    }
+    await Promise.all([
+      fs.rm(app_path, { recursive: true, force: true }),
+      execAsync(`docker rm -f ${container_name}`)
+    ]);
+  });
+  it("creates minimal sealious app", async function() {
+    console.log("	cloning sealious-minimal...");
+    await execAsync(
+      `git clone https://hub.sealcode.org/source/sealious-minimal.git ${app_path} && cd ${app_path} && git checkout 710b873`
+    );
+    console.log("	installing 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("	running add-route and building app...");
+    await execAsync(
+      `cd ${app_path} && ${callSealgenBin()} add-route --url=/sample --action=Sample --mode=page && ${callSealgenBin()} build`
+    );
+    console.log(
+      "	starting 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("	running app and making request to the generated url...");
+    const env = { ...process.env, SEALIOUS_MONGO_PORT: port.toString() };
+    const node_args = [`${app_path}/dist/back/index.js`];
+    console.log(
+      "EXECUTING",
+      `${Object.entries(env).map(([key, value]) => `${key}=${value}`).join(" ")} node ${node_args.join(" ")}`
+    );
+    let app_start = spawn(`node`, node_args, {
+      env
+    });
+    app_start.stdout.on("data", (data) => console.log(data.toString()));
+    app_start.stderr.on("data", (data) => console.log(data.toString()));
+    if (app_start.pid == void 0)
+      throw new Error("node failed to start");
+    node_pid = app_start.pid;
+    await waitPort({
+      host: "localhost",
+      port: 8080,
+      output: "silent",
+      timeout: 6e3
+    });
+    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");
+    }
+  }, 25e4);
+});
+//# sourceMappingURL=add-route.test.js.map

package/dist/back/routes/sample.page.js

@@ -0,0 +1,17 @@
+import { Page } from "@sealcode/sealgen";
+import html from "../html.js";
+const actionName = "Sample";
+var sample_page_default = new class SamplePage extends Page {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async canAccess(_) {
+    return { canAccess: true, message: "" };
+  }
+  async render(ctx) {
+    return html(ctx, "Sample", /* @__PURE__ */ React.createElement("div", null));
+  }
+}();
+export {
+  actionName,
+  sample_page_default as default
+};
+//# sourceMappingURL=sample.page.js.map

package/dist/back/routes/sample.test.js

@@ -0,0 +1,39 @@
+import { withProdApp } from "../test_utils/with-prod-app.js";
+import { VERY_LONG_TEST_TIMEOUT, webhintURL } from "../test_utils/webhint.js";
+import { SampleURL } from "./urls.js";
+import { getBrowser } from "../test_utils/browser-creator.js";
+describe("Sample webhint", () => {
+  it(
+    "doesn't crash",
+    async function() {
+      return withProdApp(async ({ base_url, rest_api }) => {
+        await rest_api.get(SampleURL);
+        await webhintURL(base_url + SampleURL);
+      });
+    },
+    VERY_LONG_TEST_TIMEOUT
+  );
+});
+describe("Sample", () => {
+  let page;
+  let browser;
+  let context;
+  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 + SampleURL);
+      });
+    },
+    VERY_LONG_TEST_TIMEOUT
+  );
+});
+//# sourceMappingURL=sample.test.js.map

package/dist/build.js

@@ -0,0 +1,149 @@
+import { build, context } from "esbuild";
+import { promises as fs } from "fs";
+import * as chokidar from "chokidar";
+import { default as glob } from "tiny-glob";
+import { generate_css_includes } from "./find-css-includes.js";
+import { sleep } from "./utils/sleep.js";
+import { generateCollections } from "./generate-collections.js";
+import { generateRoutes } from "./generate-routes.js";
+import { generateComponents } from "./generate-components.js";
+import { make_notifier } from "./notifier.js";
+import getPort from "get-port";
+import { remove_named_imports } from "../remove-named-imports.js";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+async function get_notifier_port() {
+  return getPort({ port: 4e3 });
+}
+async function write_notifier_config(watch, port) {
+  const config = { watch };
+  if (port) {
+    config.port = port;
+  }
+  await fs.writeFile(
+    target_locreq.resolve("public/dist/notifier.json"),
+    JSON.stringify(config)
+  );
+}
+async function build_ts() {
+  await Promise.all([
+    generateCollections(),
+    generateRoutes(),
+    generateComponents()
+  ]);
+  const entryPoints = (await glob("./src/back/**/*.{ts,tsx}")).filter(
+    (path) => !path.includes(".#")
+  );
+  try {
+    await build({
+      entryPoints,
+      sourcemap: true,
+      bundle: false,
+      jsxFactory: "TempstreamJSX.createElement",
+      outdir: "./dist/back",
+      logLevel: "info",
+      platform: "node",
+      target: "es2022",
+      format: "esm",
+      plugins: [remove_named_imports]
+    });
+  } catch (e) {
+    console.error(e.message);
+  }
+}
+async function complex_build(watch) {
+  const loader = Object.fromEntries(
+    ["png", "svg", "jpg", "gif", "jpeg", "otf", "ttf"].map(
+      (ext) => ["." + ext, "file"]
+    )
+  );
+  let css_build = await context({
+    entryPoints: ["./src/main.css"],
+    sourcemap: true,
+    bundle: true,
+    outdir: "./public/dist",
+    logLevel: "info",
+    // plugins: [sassPlugin()],
+    loader
+  });
+  let ongoing_ts = false;
+  let ongoing_css = false;
+  let ongoing_ts_promise = null;
+  if (watch) {
+    const watcher = chokidar.watch("src", { ignoreInitial: true });
+    const port = await get_notifier_port();
+    const notifier = make_notifier(port);
+    await write_notifier_config(watch, port);
+    watcher.on("all", async (_, path) => {
+      if (!css_build)
+        return;
+      if (path.includes(".#"))
+        return;
+      if (path.endsWith(".css") && !path.endsWith("/includes.css")) {
+        if (ongoing_css) {
+          return;
+        }
+        ongoing_css = true;
+        await generate_css_includes();
+        try {
+          await css_build?.rebuild?.();
+          console.log(`Built main.css [on ${path}]`);
+        } catch (e) {
+          console.error(e.message);
+          await sleep(200);
+          css_build?.rebuild?.().catch((e2) => console.error(e2?.message));
+        }
+        if (ongoing_ts_promise) {
+          await ongoing_ts_promise;
+        }
+        notifier("css");
+        ongoing_css = false;
+      }
+      if ((path.endsWith(".ts") || path.endsWith(".tsx")) && !path.endsWith("src/back/collections/collections.ts") && !path.endsWith("src/back/routes/routes.ts") && !path.endsWith("src/back/routes/urls.ts")) {
+        if (ongoing_ts) {
+          return;
+        }
+        ongoing_ts = true;
+        ongoing_ts_promise = build_ts();
+        await ongoing_ts_promise;
+        notifier("ts");
+        ongoing_ts_promise = null;
+        console.log(`Finished TS build [on ${path}]`);
+        ongoing_ts = false;
+      }
+    });
+  } else {
+    await write_notifier_config(watch);
+  }
+  await generate_css_includes();
+  await Promise.all([css_build.rebuild(), build_ts()]);
+  if (watch) {
+    css_build?.rebuild?.();
+  } else {
+    css_build.dispose();
+  }
+}
+async function buildProject({
+  watch
+}) {
+  try {
+    await build({
+      entryPoints: ["./src/front/index.ts"],
+      sourcemap: true,
+      outfile: "./public/dist/bundle.js",
+      logLevel: "info",
+      bundle: true
+    });
+    await complex_build(watch);
+  } catch (e) {
+    console.log("CAUGHT!");
+    console.error(e.message);
+    if (!watch) {
+      process.exit(1);
+    }
+  }
+}
+export {
+  buildProject
+};
+//# sourceMappingURL=build.js.map

package/dist/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { addCollection } from "./add-collection.js";
+import { addJDDComponent } from "./add-jdd-component.js";
+import { addRoute } from "./add-route.js";
+import { buildProject } from "./build.js";
+import { generate_css_includes } from "./find-css-includes.js";
+import { generateCollections } from "./generate-collections.js";
+import { generateComponents } from "./generate-components.js";
+import { generateRoutes } from "./generate-routes.js";
+import { makeEnv } from "./make-env.js";
+import yargs from "yargs/yargs";
+const actions = {
+  "add-collection": addCollection,
+  "add-route": addRoute,
+  "generate-collections": generateCollections,
+  "generate-components": generateComponents,
+  "generate-routes": generateRoutes,
+  "generate-css-includes": generate_css_includes,
+  build: buildProject,
+  default: async function() {
+    console.log("Usage: `npx sealgen <action>`");
+    console.log(
+      `Available actions: ${Object.keys(actions).filter((e) => e != "default").join(", ")}`
+    );
+  },
+  "make-env": makeEnv,
+  "add-component": addJDDComponent
+};
+void async function() {
+  const action = process.argv.at(2);
+  const fn = actions[action || "default"] || actions.default;
+  const args = yargs(process.argv).argv;
+  await fn(args);
+}();
+//# sourceMappingURL=cli.js.map

package/dist/components/components.js

@@ -0,0 +1,3 @@
+export * from "./tabs.js";
+export * from "./toggle-modal.js";
+//# sourceMappingURL=components.js.map

package/{lib → dist}/components/tabs.js

@@ -1,11 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tabs = void 0;
-const tempstream_1 = require("tempstream");
+import { tempstream } from "tempstream";
 function name_to_id(str) {
-    return str.replace(/\W/g, "-");
+  return str.replace(/\W/g, "-");
 }
-const style = (hide_tabs_width) => /* HTML */ `<style>
+const style = (hide_tabs_width) => (
+  /* HTML */
+  `<style>
 	.tab-label {
 		height: 45px;
 		line-height: 45px;
@@ -50,13 +49,17 @@ const style = (hide_tabs_width) => /* HTML */ `<style>
 			display: block !important;
 		}
 	}
-</style>`;
-function tabs(tabs, selected_tab_style = "font-weight: bold;", selected_index = 0, hide_tabs_width = 0) {
-    return /* HTML */ (0, tempstream_1.tempstream) `${style(hide_tabs_width)}
-	${Object.keys(tabs)
-        .map((tab_title, index) => {
-        const id = name_to_id(tab_title);
-        return /* HTML */ `<input
+</style>`
+);
+function tabs(tabs2, selected_tab_style = "font-weight: bold;", selected_index = 0, hide_tabs_width = 0) {
+  return (
+    /* HTML */
+    tempstream`${style(hide_tabs_width)}
+	${Object.keys(tabs2).map((tab_title, index) => {
+      const id = name_to_id(tab_title);
+      return (
+        /* HTML */
+        `<input
 					type="radio"
 					name="tabs"
 					id="${id}"
@@ -66,12 +69,14 @@ function tabs(tabs, selected_tab_style = "font-weight: bold;", selected_index =
 				/>
 				<label class="tab-label tab-label--${id}" for="${id}">
 					${tab_title}
-				</label>`;
-    })
-        .join("\n")}
-	${Object.entries(tabs).map(([title, content]) => {
-        const id = name_to_id(title);
-        return /* HTML */ (0, tempstream_1.tempstream) `<div class="tab-label tab-label--mobile">
+				</label>`
+      );
+    }).join("\n")}
+	${Object.entries(tabs2).map(([title, content]) => {
+      const id = name_to_id(title);
+      return (
+        /* HTML */
+        tempstream`<div class="tab-label tab-label--mobile">
 					${title}
 				</div>
 				<div class="tab-content tab-content--${id}">${content}</div>
@@ -85,8 +90,12 @@ function tabs(tabs, selected_tab_style = "font-weight: bold;", selected_index =
 					.tab-radio--${id}:checked ~ label.tab-label--${id} {
 						${selected_tab_style}
 					}
-				</style>`;
-    })}`;
+				</style>`
+      );
+    })}`
+  );
 }
-exports.tabs = tabs;
-//# sourceMappingURL=tabs.js.map
+export {
+  tabs
+};
+//# sourceMappingURL=tabs.js.map

package/{lib → dist}/components/toggle-modal.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toggleModal = void 0;
-const tempstream_1 = require("tempstream");
-const utils_1 = require("../utils/utils");
+import { tempstream } from "tempstream";
+import { makeSlug } from "../utils/utils.js";
 function toggleModal(options) {
-    const { contentWrapped, contentUnwrapped, name } = options;
-    const id = (0, utils_1.makeSlug)(name);
-    return (0, tempstream_1.tempstream /* HTML */) `<style>
+  const { contentWrapped, contentUnwrapped, name } = options;
+  const id = makeSlug(name);
+  return tempstream`<style>
 			.toggle-modal__wrapped {
 				display: none;
 			}
@@ -46,5 +43,7 @@ function toggleModal(options) {
 			<div class="toggle-modal__unwrapped">${contentUnwrapped(id)}</div>
 		</div>`;
 }
-exports.toggleModal = toggleModal;
-//# sourceMappingURL=toggle-modal.js.map
+export {
+  toggleModal
+};
+//# sourceMappingURL=toggle-modal.js.map

package/dist/example.test.js

@@ -0,0 +1,5 @@
+describe("empty test", () => {
+  it("empty test", () => {
+  });
+});
+//# sourceMappingURL=example.test.js.map