@sealcode/sealgen 0.15.22 → 0.15.24

package/@types/src/add-collection.d.ts

@@ -1 +1 @@
-export declare function addCollection(): Promise<void>;
+export declare function addCollection(params?: Record<string, string | boolean>): Promise<void>;

package/@types/src/page/list.d.ts

@@ -9,6 +9,7 @@ import { SimpleFormField } from "../forms/fields/simple-form-field.js";
 import { FormDataValue } from "../forms/form-types.js";
 export declare const BasePagePropsShape: {};
 export type BasePageProps = ShapeToType<typeof BasePagePropsShape>;
+export declare const DEFAULT_ITEMS_PER_PAGE = 12;
 export declare const BaseListPageFields: {
     readonly page: NumberField<1, false>;
     readonly itemsPerPage: NumberField<12, false>;

package/@types/src/page/sealious-list.d.ts

@@ -9,7 +9,7 @@ export declare abstract class SealiousItemListPage<C extends Collection, F exten
     getTotalPages(ctx: Context, itemsPerPage: number): Promise<number>;
     protected addFilter(ctx: Context, list: ItemList<C>): Promise<void>;
     makeQuery(ctx: Context): Promise<ItemList<C>>;
-    getItems(ctx: Context, page: number, itemsPerPage: number): Promise<CollectionItem<C>[]>;
+    getItems(ctx: Context, page: number, itemsPerPage: number | null): Promise<CollectionItem<C>[]>;
     getFilterValues(ctx: Context): Promise<Record<string, string | undefined>>;
     renderItem(_: Context, item: CollectionItem<C>, _index: number): Promise<FlatTemplatable>;
     canAccess: (ctx: Context) => Promise<{

package/@types/src/page/sealious-list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/test_utils/exec_async.d.ts

@@ -0,0 +1 @@
+export declare const execAsync: (cmd: string) => Promise<void>;

package/@types/src/test_utils/test-on-real-app.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from "events";
+export declare const callSealgenBin: () => string;
+export declare class RealAppTest {
+    node_pid: number;
+    app_port: number;
+    mongo_port: number;
+    app_path: string;
+    container_name: string;
+    emitter: EventEmitter;
+    static init(): Promise<RealAppTest>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    runSealgenCommand(command: string): Promise<void>;
+    throwIfItKillsTheApp<T>(cb: () => Promise<T>): Promise<T>;
+    httpGet(path: string): Promise<{
+        status: number;
+        response: string;
+    }>;
+    httpPOST(path: string, body: Record<string, unknown>): Promise<{
+        status: number;
+        response: string;
+    }>;
+}

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

@@ -2,4 +2,4 @@
 import { Readable } from "stream";
 import { FlatTemplatable } from "tempstream";
 export declare function getRequiredClass(isRequired: boolean): string;
-export declare function inputWrapper(modifiers: string[], input: FlatTemplatable): Readable;
+export declare function inputWrapper(type: string, modifiers: string[], input: FlatTemplatable): Readable;

package/lib/add-collection.js

@@ -1,18 +1,28 @@
 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";
 import { toKebabCase, toPascalCase } from "js-convert-case";
 const target_locreq = _locreq(process.cwd());
-async function addCollection() {
-  const collection_name = toPascalCase(
-    await question(
-      "What's the name of the collection class: ",
-      (s) => s.length > 3
-    )
-  );
+import prompts from "prompts";
+async function addCollection(params = {}) {
+  prompts.override(params);
+  const response = await prompts([
+    {
+      type: "text",
+      name: "collection_name",
+      message: "What's the name of the collection class: ",
+      validate: (s) => s.length > 3 ? true : "Should be at least 3 characters long",
+      format: function(action) {
+        return toPascalCase(action);
+      }
+    }
+  ]);
+  const collection_name = response.collection_name;
+  if (!collection_name) {
+    throw new Error("Empty collection name, please try again");
+  }
   const file_path = target_locreq.resolve(
     `src/back/collections/${toKebabCase(collection_name)}.ts`
   );

package/lib/add-route.test.js

@@ -1,98 +1,15 @@
-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";
-import { module_dirname } from "./utils/module-dirname.js";
-const locreq = _locreq(module_dirname(import.meta.url));
-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("lib/cli.js")}`;
+import { RealAppTest } from "./test_utils/test-on-real-app.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 df8cccf`
-    );
-    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 && ${callSealgenBin()} make-env`
-    );
-    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 mongo_port = await getPort();
-    const app_port = await getPort();
-    await execAsync(
-      `docker run -p ${mongo_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: mongo_port.toString(),
-      SEALIOUS_PORT: app_port.toString()
-    };
-    const node_args = [`${app_path}/dist/back/index.js`];
-    console.log(
-      "EXECUTING APP",
-      `${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("APP OUTPUT:", 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: app_port,
-      output: "silent",
-      timeout: 6e3
-    });
-    const res = await axios.get(`http://localhost:${app_port}/sample`);
+  it("creates minimal sealious app and adds a simple route that works", async function() {
+    const test_app = await RealAppTest.init();
+    const path = "/sample";
+    await test_app.runSealgenCommand(`add-route --url=${path} --action=Sample --mode=page`);
+    await test_app.start();
+    const res = await test_app.httpGet(path);
     if (res.status != 200) {
-      throw new Error("url generated by add-route exists but doesnt return 200");
+      throw new Error("url generated by add-route exists but doesn't return 200");
     }
+    await test_app.close();
   }).timeout(100 * 1e3);
 });
 //# sourceMappingURL=add-route.test.js.map

package/lib/forms/controls/checkboxed-list-input.js

@@ -8,34 +8,43 @@ class CheckboxedListInput extends FormFieldControl {
     this.options = options;
   }
   async render(fctx) {
-    const { parsed: currentValue } = await this.field.getValue(
-      fctx.ctx,
-      fctx.data
-    );
+    const {
+      valid,
+      message,
+      parsed: currentValue
+    } = await this.field.getValue(fctx.ctx, fctx.data, true);
     const pickedValues = Object.entries(currentValue || {}).filter(([, is_on]) => is_on).map(([key]) => key);
     const [options, isVisible] = await Promise.all([
       this.field.generateOptions(fctx.ctx),
       this.field.isVisible(fctx.ctx)
     ]);
     const { name, required } = this.field;
-    return tempstream`${isVisible ? options.map(
-      ({ value, label }) => inputWrapper(
-        [name, getRequiredClass(required)],
-        /* HTML */
-        `
-							<input
-								type="checkbox"
-								id="${name}.${value}"
-								name="${name}.${value}"
-								${pickedValues.includes(value) ? "checked" : ""}
-								form=${fctx.form_id}
-							/>
-							<label for="${name}.${value}"
-								>${label || value}</label
-							>
-						`
-      )
-    ) : ""}`;
+    return inputWrapper(
+      "checkboxed-list",
+      [name, getRequiredClass(required)],
+      tempstream`<label
+					>${this.options.label || this.field.name}</label
+				>${isVisible ? options.map(
+        ({ value, label }) => inputWrapper(
+          "checkbox",
+          [name],
+          /* HTML */
+          `
+									<input
+										type="checkbox"
+										id="${name}.${value}"
+										name="${name}.${value}"
+										${pickedValues.includes(value) ? "checked" : ""}
+										form=${fctx.form_id}
+									/>
+									<label for="${name}.${value}"
+										>${label || value}</label
+									>
+								`
+        )
+      ) : ""}
+				${~valid && fctx.validate ? `<div class="input__error">${message}</div>` : ""}`
+    );
   }
 }
 export {

package/lib/forms/controls/checkboxed-list-input.test.js

@@ -7,6 +7,7 @@ import { Form } from "../form.js";
 import { CheckboxedListInput } from "./checkboxed-list-input.js";
 import { getBrowser } from "../../utils/browser-creator.js";
 import assert from "assert";
+import { sleep } from "../../utils/sleep.js";
 describe("checkboxed-list", () => {
   describe("basic tests", async () => {
     let server;
@@ -58,6 +59,178 @@ describe("checkboxed-list", () => {
       await page.getByRole("button", { name: "Wy\u015Blij" }).click();
       assert.deepStrictEqual(received_values, { syllables: { co: "on", de: "on" } });
     });
+    describe("behavior with (non)required", () => {
+      it("allows to send a form when no value is selected and fiels is not required", async () => {
+        const port = await getPort();
+        console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+        const app = new Koa();
+        const router = new Router();
+        const fields = {
+          syllables: new CheckboxedListField(false, async () => {
+            await sleep(10);
+            return ["sa", "mple", "co", "de"].map((s) => ({
+              value: s,
+              label: s.toLocaleUpperCase()
+            }));
+          })
+        };
+        let submit_called = false;
+        mount(
+          router,
+          "/",
+          new class extends Form {
+            constructor() {
+              super(...arguments);
+              this.fields = fields;
+              this.controls = [new CheckboxedListInput(fields.syllables)];
+            }
+            async onSubmit(ctx) {
+              submit_called = true;
+            }
+            async canAccess(_) {
+              return { canAccess: true, message: "" };
+            }
+          }(),
+          true
+        );
+        app.use(router.routes()).use(router.allowedMethods());
+        server = app.listen(port);
+        browser = await getBrowser();
+        const context = await browser.newContext();
+        page = await context.newPage();
+        await page.goto(`http://localhost:${port}`);
+        await page.getByRole("button", { name: "Wy\u015Blij" }).click();
+        await sleep(100);
+        assert(submit_called);
+      });
+      it("does not allow to send a form when no value is selected and field IS required", async () => {
+        const port = await getPort();
+        console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+        const app = new Koa();
+        const router = new Router();
+        const fields = {
+          syllables: new CheckboxedListField(true, async () => {
+            await sleep(10);
+            return ["sa", "mple", "co", "de"].map((s) => ({
+              value: s,
+              label: s.toLocaleUpperCase()
+            }));
+          })
+        };
+        let submit_called = false;
+        mount(
+          router,
+          "/",
+          new class extends Form {
+            constructor() {
+              super(...arguments);
+              this.fields = fields;
+              this.controls = [new CheckboxedListInput(fields.syllables)];
+            }
+            async onSubmit(ctx) {
+              submit_called = true;
+            }
+            async canAccess(_) {
+              return { canAccess: true, message: "" };
+            }
+          }(),
+          true
+        );
+        app.use(router.routes()).use(router.allowedMethods());
+        server = app.listen(port);
+        browser = await getBrowser();
+        const context = await browser.newContext();
+        page = await context.newPage();
+        await page.goto(`http://localhost:${port}`);
+        await page.getByRole("button", { name: "Wy\u015Blij" }).click();
+        await sleep(100);
+        assert(submit_called == false);
+        await page.getByText(/empty value/).click({ timeout: 500 });
+      });
+      it("allows to send a form when no value is selected and field IS required", async () => {
+        const port = await getPort();
+        console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+        const app = new Koa();
+        const router = new Router();
+        const fields = {
+          syllables: new CheckboxedListField(true, async () => {
+            await sleep(10);
+            return ["sa", "mple", "co", "de"].map((s) => ({
+              value: s,
+              label: s.toLocaleUpperCase()
+            }));
+          })
+        };
+        let submit_called = false;
+        mount(
+          router,
+          "/",
+          new class extends Form {
+            constructor() {
+              super(...arguments);
+              this.fields = fields;
+              this.controls = [new CheckboxedListInput(fields.syllables)];
+            }
+            async onSubmit(ctx) {
+              submit_called = true;
+            }
+            async canAccess(_) {
+              return { canAccess: true, message: "" };
+            }
+          }(),
+          true
+        );
+        app.use(router.routes()).use(router.allowedMethods());
+        server = app.listen(port);
+        browser = await getBrowser();
+        const context = await browser.newContext();
+        page = await context.newPage();
+        await page.goto(`http://localhost:${port}`);
+        await page.getByLabel("DE").check();
+        await page.getByRole("button", { name: "Wy\u015Blij" }).click();
+        await sleep(100);
+        assert(submit_called);
+      });
+    });
+    it("renders the label", async () => {
+      const port = await getPort();
+      console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+      const app = new Koa();
+      const router = new Router();
+      const fields = {
+        syllables: new CheckboxedListField(true, async () => {
+          return ["sa", "mple", "co", "de"].map((s) => ({
+            value: s,
+            label: s.toLocaleUpperCase()
+          }));
+        })
+      };
+      mount(
+        router,
+        "/",
+        new class extends Form {
+          constructor() {
+            super(...arguments);
+            this.fields = fields;
+            this.controls = [new CheckboxedListInput(fields.syllables, { label: "ABC" })];
+          }
+          async onSubmit(ctx) {
+          }
+          async canAccess(_) {
+            return { canAccess: true, message: "" };
+          }
+        }(),
+        true
+      );
+      app.use(router.routes()).use(router.allowedMethods());
+      server = app.listen(port);
+      browser = await getBrowser();
+      const context = await browser.newContext();
+      page = await context.newPage();
+      await page.goto(`http://localhost:${port}`);
+      await page.getByRole("button", { name: "Wy\u015Blij" }).click();
+      await page.getByText(/ABC/).click({ timeout: 500 });
+    });
   });
 });
 //# sourceMappingURL=checkboxed-list-input.test.js.map

package/lib/forms/controls/multiple-files.js

@@ -161,6 +161,7 @@ class MultipleFiles extends FormFieldControl {
       ])
     )).filter(([_, f]) => f !== null);
     return inputWrapper(
+      "multiple-files",
       ["multiple-files", this.field.name, ...this.getClassModifiers()],
       tempstream`
 				<label>${this.options.label || this.field.name}</label>

package/lib/forms/controls/simple-input.js

@@ -73,6 +73,7 @@ class SimpleInput extends FormFieldControl {
       true
     );
     return inputWrapper(
+      "simple-input",
       this.getWrapperModifiers(),
       tempstream`
 				${label ? `<label for="${id}">${label}</label>` : ""}

package/lib/forms/controls/tickable.js

@@ -33,6 +33,7 @@ class Tickable extends FormFieldControl {
     const readonly = this.options.readonly || false;
     const required = this.field.required;
     return inputWrapper(
+      this.type,
       this.getWrapperClasses(fctx.ctx, fctx.data, parsed),
       /* HTML */
       `

package/lib/forms/fields/field.js

@@ -40,7 +40,7 @@ class FormField {
     if (raw == void 0 || raw == null || raw == "") {
       return {
         parsed: null,
-        message: this.required ? "empty value" : "",
+        message: this.required ? "empty value, but field is required" : "",
         raw,
         ...validate ? { valid: !this.required } : {}
       };

package/lib/page/list.js

@@ -202,6 +202,7 @@ ${this.renderListContainer(ctx, this.renderItems(ctx, values))}`;
 export {
   BaseListPageFields,
   BasePagePropsShape,
+  DEFAULT_ITEMS_PER_PAGE,
   ListPage
 };
 //# sourceMappingURL=list.js.map

package/lib/page/sealious-list.js

@@ -1,4 +1,7 @@
-import { ListPage } from "./list.js";
+import {
+  DEFAULT_ITEMS_PER_PAGE,
+  ListPage
+} from "./list.js";
 import { peopleWhoCan } from "./access-control.js";
 import qs from "qs";
 import { is, predicates } from "@sealcode/ts-predicates";
@@ -39,7 +42,7 @@ class SealiousItemListPage extends ListPage {
   async getItems(ctx, page, itemsPerPage) {
     const query = await this.makeQuery(ctx);
     await this.addFilter(ctx, query);
-    const { items } = await query.paginate({ items: itemsPerPage, page }).fetch();
+    const { items } = await query.paginate({ items: itemsPerPage || DEFAULT_ITEMS_PER_PAGE, page }).fetch();
     return items;
   }
   async getFilterValues(ctx) {

package/lib/page/sealious-list.test.js

@@ -0,0 +1,24 @@
+import assert from "assert";
+import { RealAppTest } from "../test_utils/test-on-real-app.js";
+describe("sealious-list test", () => {
+  it("creates minimal sealious app and adds a simple route that works", async function() {
+    const test_app = await RealAppTest.init();
+    const url = "/list";
+    await test_app.runSealgenCommand(`add-collection --collection_name=samples`);
+    await test_app.runSealgenCommand(
+      `add-route --url=${url} --action=List --mode=list --collection=samples`
+    );
+    await test_app.start();
+    const res_post = await test_app.httpPOST("/api/v1/collections/samples", {
+      content: "some-content"
+    });
+    assert(res_post.status == 201);
+    const res = await test_app.httpGet(url);
+    if (res.status != 200) {
+      throw new Error("url generated by add-route exists but doesn't return 200");
+    }
+    assert(res.response.includes("some-content"));
+    await test_app.close();
+  }).timeout(100 * 1e3);
+});
+//# sourceMappingURL=sealious-list.test.js.map

package/lib/test_utils/exec_async.js

@@ -0,0 +1,24 @@
+import { exec } from "child_process";
+const execAsync = (cmd) => {
+  return new Promise((resolve, reject) => {
+    const process = exec(cmd);
+    console.log("EXECUTING", cmd);
+    process?.stdout?.on("data", (data) => {
+      console.log(`stdout: ${data}`);
+    });
+    process?.stderr?.on("data", (data) => {
+      console.log(`stdout: ${data}`);
+    });
+    process.on("exit", (code) => {
+      if (code == 0) {
+        resolve();
+      } else {
+        reject();
+      }
+    });
+  });
+};
+export {
+  execAsync
+};
+//# sourceMappingURL=exec_async.js.map