@sealcode/sealgen 0.11.8 → 0.12.2

package/dist/forms/fields/field.js

@@ -0,0 +1,82 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { t } from "../../utils/translate.js";
+function fieldsToShape(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => [key, value.predicate])
+  );
+}
+class FormField {
+  constructor(required) {
+    this.required = required;
+    this.predicate = predicates.unknown;
+    this.mapToFilter = (value) => value;
+  }
+  async init(fieldname) {
+    this.name = fieldname;
+  }
+  async _validate(ctx, value) {
+    if (this.required && (value === "" || value === null || value === void 0)) {
+      return {
+        valid: false,
+        message: t(
+          ctx,
+          "field_is_required",
+          [],
+          "This field is required"
+        )
+      };
+    }
+    return this.isValueValid(ctx, value);
+  }
+  async isValueValid(ctx, value) {
+    return { valid: true, message: "" };
+  }
+  async getValue(ctx, all_form_values) {
+    if (Object.keys(all_form_values || {}).length === 0) {
+      return {
+        parsed: this.getEmptyValue(),
+        valid: true,
+        message: "",
+        raw: ""
+      };
+    }
+    const raw = all_form_values[this.name];
+    const {
+      parsable,
+      parsed_value,
+      error: parse_error
+    } = await this.parse(ctx, raw);
+    if (!parsable) {
+      return {
+        valid: false,
+        parsed: this.getEmptyValue(),
+        raw,
+        message: parse_error || "Error"
+      };
+    }
+    const { valid, message } = await this._validate(
+      ctx,
+      parsed_value
+    );
+    return {
+      parsed: parsed_value,
+      valid,
+      message,
+      raw: all_form_values[this.name]
+    };
+  }
+  setMapToFilter(fn) {
+    this.mapToFilter = fn;
+    return this;
+  }
+  //return undefined here to delete a value
+  async getDatabaseValue(ctx, data) {
+    const { parsed } = await this.getValue(ctx, data);
+    return parsed;
+  }
+}
+export {
+  FormField,
+  fieldsToShape
+};
+//# sourceMappingURL=field.js.map

package/dist/forms/fields/fields.js

@@ -0,0 +1,16 @@
+export * from "./simple-form-field.js";
+export * from "./checkboxed-list.js";
+export * from "./collection-field.js";
+export * from "./number.js";
+export * from "./pick-from-list.js";
+export * from "./regexp.js";
+export * from "./email.js";
+export * from "./enum.js";
+export * from "./boolean.js";
+export * from "./enum-multiple.js";
+export * from "./existing-sealious-value.js";
+export * from "./file.js";
+export * from "./multiple-files.js";
+export * from "./reverse-single-reference.js";
+export * from "./structured-array.js";
+//# sourceMappingURL=fields.js.map

package/dist/forms/fields/file.js

@@ -0,0 +1,63 @@
+import {
+  hasFieldOfType,
+  hasShape,
+  is,
+  predicates
+} from "@sealcode/ts-predicates";
+import Sealious from "sealious";
+import { FormField } from "./field.js";
+class File extends FormField {
+  async parse(ctx, raw_value) {
+    let result;
+    if (raw_value instanceof Sealious.File || is(raw_value, predicates.object) && hasShape(
+      {
+        filename: predicates.string,
+        id: predicates.string
+      },
+      raw_value
+    ) && raw_value.id) {
+      const file = await Sealious.File.fromID(
+        ctx.$app,
+        raw_value.id
+      );
+      result = {
+        parsed_value: { old: file, new: null },
+        error: null,
+        parsable: true
+      };
+    } else if (!is(raw_value, predicates.object)) {
+      result = {
+        parsed_value: null,
+        error: "Expected a field with old.id:string, old.filename:string and new?:File",
+        parsable: false
+      };
+    } else {
+      const old_file = hasFieldOfType(raw_value, "old", predicates.object) && hasShape(
+        { id: predicates.string, filename: predicates.string },
+        raw_value.old
+      ) && raw_value.old.id ? await Sealious.File.fromID(ctx.$app, raw_value.old.id) : null;
+      const new_file = hasFieldOfType(
+        raw_value,
+        "new",
+        predicates.array(predicates.object)
+      ) && raw_value.new[0] instanceof SealiousFile ? raw_value.new[0] : null;
+      result = {
+        parsable: true,
+        error: null,
+        parsed_value: { old: old_file, new: new_file }
+      };
+    }
+    return result;
+  }
+  async getDatabaseValue(ctx, data) {
+    const { parsed } = await this.getValue(ctx, data);
+    return parsed.new || void 0;
+  }
+  getEmptyValue() {
+    return { old: null, new: null };
+  }
+}
+export {
+  File
+};
+//# sourceMappingURL=file.js.map

package/dist/forms/fields/multiple-files.js

@@ -0,0 +1,18 @@
+import { FormField } from "./field.js";
+class MultipleFiles extends FormField {
+  constructor(collection_field, getItemId) {
+    super(false);
+    this.collection_field = collection_field;
+    this.getItemId = getItemId;
+  }
+  getEmptyValue() {
+    return void 0;
+  }
+  async parse() {
+    return { parsed_value: void 0, parsable: true, error: null };
+  }
+}
+export {
+  MultipleFiles
+};
+//# sourceMappingURL=multiple-files.js.map

package/dist/forms/fields/number.js

@@ -0,0 +1,42 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+class NumberField extends FormField {
+  constructor(required, default_value, options = {}) {
+    super(required);
+    this.default_value = default_value;
+    this.options = options;
+    this.predicate = predicates.number;
+  }
+  async isValueValid(_, value) {
+    if (is(value, predicates.string) && !isNaN(parseFloat(value)) && parseFloat(value).toString() == value.trim() || is(value, predicates.number) || (is(value, predicates.undefined) || value == "") && !this.required) {
+      return { valid: true, message: "" };
+    }
+    return { valid: false, message: "Prosz\u0119 wprowadzi\u0107 liczb\u0119" };
+  }
+  async parse(_, value) {
+    if (is(value, predicates.string) && !isNaN(parseFloat(value)) && parseFloat(value).toString() == value.trim() || is(value, predicates.number)) {
+      return {
+        parsable: true,
+        parsed_value: this.options.decimalDigits ? parseFloat(
+          parseFloat(value.toString()).toFixed(
+            this.options.decimalDigits
+          )
+        ) : parseFloat(value.toString()),
+        error: null
+      };
+    } else {
+      return {
+        parsable: false,
+        parsed_value: null,
+        error: "Please enter a number"
+      };
+    }
+  }
+  getEmptyValue() {
+    return this.default_value;
+  }
+}
+export {
+  NumberField
+};
+//# sourceMappingURL=number.js.map

package/dist/forms/fields/number.test.js

@@ -0,0 +1,31 @@
+import assert from "assert";
+import * as Sealgen from "../../index.js";
+const { Fields } = Sealgen;
+describe("number field", () => {
+  const ctx = {};
+  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);
+  });
+});
+//# sourceMappingURL=number.test.js.map

package/dist/forms/fields/pick-from-list.js

@@ -0,0 +1,34 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { SimpleFormField } from "./simple-form-field.js";
+class PickFromListField extends SimpleFormField {
+  constructor(required, generateOptions, customValidation = (ctx, value, instance) => instance.valueInList(ctx, value)) {
+    super(required);
+    this.required = required;
+    this.generateOptions = generateOptions;
+    this.customValidation = customValidation;
+    this.predicate = predicates.string;
+  }
+  isValueValid(ctx, value) {
+    return this.customValidation(ctx, value, this);
+  }
+  async valueInList(ctx, value) {
+    const options = await this.generateOptions(ctx);
+    if (!is(value, predicates.string)) {
+      return { valid: false, message: "not a string" };
+    }
+    if (this.required && !options.map((o) => o.value).includes(value)) {
+      return {
+        valid: false,
+        message: `"${value}" is not one of the options`
+      };
+    }
+    return { valid: true, message: "" };
+  }
+  getEmptyValue() {
+    return "";
+  }
+}
+export {
+  PickFromListField
+};
+//# sourceMappingURL=pick-from-list.js.map

package/dist/forms/fields/pick-from-list.test.js

@@ -0,0 +1,17 @@
+import assert from "assert";
+import { Fields } from "../../index.js";
+describe("pick-from-list field", () => {
+  const ctx = {};
+  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)).valid, false);
+    assert.strictEqual((await field.isValueValid(ctx, "samplevv")).valid, true);
+    assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+  });
+});
+//# sourceMappingURL=pick-from-list.test.js.map

package/dist/forms/fields/proxy-field.js

@@ -0,0 +1,23 @@
+import { FormField } from "./field.js";
+class ProxyFormField extends FormField {
+  constructor(required, name, empty_value, parsed_value) {
+    super(required);
+    this.name = name;
+    this.empty_value = empty_value;
+    this.parsed_value = parsed_value;
+  }
+  getEmptyValue() {
+    return this.empty_value;
+  }
+  async parse() {
+    return {
+      parsable: true,
+      error: null,
+      parsed_value: this.parsed_value
+    };
+  }
+}
+export {
+  ProxyFormField
+};
+//# sourceMappingURL=proxy-field.js.map

package/dist/forms/fields/regexp.js

@@ -0,0 +1,42 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+class RegExpField extends FormField {
+  constructor(required, regexp, error_message, default_value = "") {
+    super(required);
+    this.regexp = regexp;
+    this.error_message = error_message;
+    this.default_value = default_value;
+    this.predicate = predicates.string;
+  }
+  async isValueValid(_, value) {
+    if (!is(value, predicates.string)) {
+      return { valid: false, message: "expected a string" };
+    }
+    if (this.regexp.exec(value)) {
+      return { valid: true, message: "" };
+    }
+    return { valid: false, message: this.error_message };
+  }
+  async parse(_, value) {
+    if (is(value, predicates.string)) {
+      return {
+        parsable: true,
+        parsed_value: value,
+        error: null
+      };
+    } else {
+      return {
+        parsable: false,
+        parsed_value: null,
+        error: "Please enter a string"
+      };
+    }
+  }
+  getEmptyValue() {
+    return this.default_value || "";
+  }
+}
+export {
+  RegExpField
+};
+//# sourceMappingURL=regexp.js.map

package/dist/forms/fields/regexp.test.js

@@ -0,0 +1,21 @@
+import assert from "assert";
+import { Fields } from "../../index.js";
+describe("regexp field", () => {
+  const ctx = {};
+  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");
+  });
+});
+//# sourceMappingURL=regexp.test.js.map

package/dist/forms/fields/reverse-single-reference.js

@@ -0,0 +1,17 @@
+import { FormField } from "./field.js";
+class ReverseSingleReference extends FormField {
+  constructor(required, sealious_field) {
+    super(required);
+    this.sealious_field = sealious_field;
+  }
+  async parse(ctx, raw_value) {
+    return { parsable: true, error: null, parsed_value: raw_value };
+  }
+  getEmptyValue() {
+    return [];
+  }
+}
+export {
+  ReverseSingleReference
+};
+//# sourceMappingURL=reverse-single-reference.js.map

package/dist/forms/fields/simple-form-field.js

@@ -0,0 +1,22 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+class SimpleFormField extends FormField {
+  constructor(required) {
+    super(required);
+    this.predicate = predicates.string;
+  }
+  async parse(_, raw_value) {
+    return {
+      parsed_value: (raw_value || "").toString(),
+      parsable: true,
+      error: null
+    };
+  }
+  getEmptyValue() {
+    return "";
+  }
+}
+export {
+  SimpleFormField
+};
+//# sourceMappingURL=simple-form-field.js.map

package/dist/forms/fields/structured-array.js

@@ -0,0 +1,21 @@
+import { FormField } from "./field.js";
+class StructuredArrayField extends FormField {
+  constructor(sealious_field) {
+    super(true);
+    this.sealious_field = sealious_field;
+  }
+  async parse(context, value) {
+    return {
+      parsable: true,
+      error: null,
+      parsed_value: value || []
+    };
+  }
+  getEmptyValue() {
+    return [];
+  }
+}
+export {
+  StructuredArrayField
+};
+//# sourceMappingURL=structured-array.js.map

package/dist/forms/form-types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=form-types.js.map

package/dist/forms/form.js

@@ -0,0 +1,203 @@
+import { randomUUID } from "crypto";
+import Router from "@koa/router";
+import { tempstream } from "tempstream";
+import {
+  hasFieldOfType,
+  hasShape,
+  is,
+  predicates
+} from "@sealcode/ts-predicates";
+import {
+  MountableWithFields
+} from "../page/mountable-with-fields.js";
+class Form extends MountableWithFields {
+  constructor() {
+    super(...arguments);
+    this.defaultSuccessMessage = "Done";
+    this.submitButtonText = "Wy\u015Blij";
+    this.action = "./";
+    this.useTurbo = true;
+    this.form_id = randomUUID();
+  }
+  async canAccess(_) {
+    return { canAccess: true, message: "" };
+  }
+  async renderError(_, error) {
+    return tempstream`<div>${error.message}</div>`;
+  }
+  makeSubmitButton() {
+    return (
+      /* HTML */
+      `<input
+			type="submit"
+			value="${this.submitButtonText}"
+			formaction="${this.action}"
+			${this.form_id ? `form="${this.form_id}"` : ""}
+		/>`
+    );
+  }
+  async render(ctx, data, show_field_errors) {
+    return tempstream`<div class="form-container">
+			${this.makeOpenFormTag(ctx)}
+			${!this.controls.some((control) => control.role == "messages") ? this.renderMessages(ctx, data) : ""}
+			${this.renderControls(
+      this.makeFormControlContext(ctx, data, show_field_errors)
+    )}
+			${this.controls.some((control) => control.role == "submit") ? "" : this.makeSubmitButton()}
+			${this.makeCloseFormTag()}
+		</div>`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async makeFormClasses(_ctx) {
+    return [];
+  }
+  makeOpenFormTag(ctx) {
+    return tempstream`<form enctype="multipart/form-data" method="POST" id="${this.form_id}" action="${this.action}" class="${this.makeFormClasses(ctx).then(
+      (classes) => classes.join(" ")
+    )}" ${this.useTurbo ? "" : `data-turbo="false"`}></form><div class="form">`;
+  }
+  makeCloseFormTag() {
+    return `</div>`;
+  }
+  async onValuesInvalid(ctx, form_messages, _field_errors) {
+    const messages = form_messages.length ? form_messages : [{ type: "error", text: "Some fields are invalid" }];
+    return {
+      action: "stay",
+      content: await this.render(
+        ctx,
+        {
+          raw_values: await this.extractRawValues(ctx),
+          messages
+        },
+        true
+      ),
+      messages
+    };
+  }
+  async onError(ctx, data, error) {
+    let error_message = "Unknown error has occured";
+    if (is(error, predicates.object) && hasShape({ message: predicates.string }, error)) {
+      error_message = error.message;
+    }
+    const messages = [{ type: "error", text: error_message }];
+    return {
+      action: "stay",
+      content: await this.render(
+        ctx,
+        {
+          raw_values: data.raw_values,
+          messages
+        },
+        true
+      )
+    };
+  }
+  async onSuccess(ctx, data, _submitResult) {
+    const messages = [
+      { type: "success", text: this.defaultSuccessMessage }
+    ];
+    return {
+      action: "stay",
+      content: await this.render(
+        ctx,
+        {
+          raw_values: data.raw_values,
+          messages
+        },
+        false
+      ),
+      messages
+    };
+  }
+  async getRawValuesOnSuccess(ctx) {
+    return this.extractRawValues(ctx);
+  }
+  async handlePost(ctx) {
+    const raw_values = await this.extractRawValues(ctx);
+    const { valid, form_messages, field_errors } = await this.validate(
+      ctx,
+      raw_values
+    );
+    if (!valid) {
+      return this.onValuesInvalid(ctx, form_messages, field_errors);
+    }
+    try {
+      ctx.status = 303;
+      const result = await this.onSubmit(ctx, {
+        raw_values,
+        messages: []
+      });
+      return this.onSuccess(
+        ctx,
+        {
+          raw_values: await this.getRawValuesOnSuccess(ctx),
+          messages: []
+        },
+        result
+      );
+    } catch (e) {
+      console.dir(e, { depth: 5 });
+      const message = is(e, predicates.object) && hasFieldOfType(e, "message", predicates.string) ? e?.message : is(e, predicates.string) ? e : "Wyst\u0105pi\u0142 b\u0142\u0105d";
+      return this.onError(
+        ctx,
+        {
+          raw_values,
+          messages: [
+            {
+              type: "error",
+              text: message
+            }
+          ]
+        },
+        e
+      );
+    }
+  }
+  mount(router, path) {
+    router.use(path, async (ctx, next) => {
+      const result = await this.canAccess(ctx);
+      if (!result.canAccess) {
+        ctx.body = this.renderError(ctx, {
+          type: "access",
+          message: result.message
+        });
+        ctx.status = 403;
+        return;
+      }
+      await next();
+    });
+    router.get(path, async (ctx) => {
+      ctx.type = "html";
+      ctx.body = await this.render(
+        ctx,
+        {
+          raw_values: await this.extractRawValues(ctx),
+          messages: []
+        },
+        false
+      );
+    });
+    router.post(path, async (ctx) => {
+      const reaction = await this.handlePost(ctx);
+      if (reaction.action == "stay") {
+        ctx.status = 422;
+        ctx.body = reaction.content;
+      } else if (reaction.action == "redirect") {
+        ctx.status = 303;
+        ctx.redirect(reaction.url);
+      }
+    });
+    const subrouter = new Router();
+    for (const control of this.controls) {
+      control.mount(subrouter);
+    }
+    router.use(path, subrouter.routes(), subrouter.allowedMethods());
+  }
+  async extractRawValues(ctx) {
+    return ctx.$body;
+  }
+}
+export {
+  Form
+};
+//# sourceMappingURL=form.js.map