@sealcode/sealgen 0.18.10 → 0.19.0

package/lib/forms/fields/deep-reverse-single-reference-list.js

@@ -0,0 +1,81 @@
+import { CheckboxedListField } from "./checkboxed-list.js";
+import { wrapKeyName } from "../../utils/wrap-attributes.js";
+class DeepReverseSingleReferenceList extends CheckboxedListField {
+  constructor(sealious_field) {
+    super(false, async (ctx) => {
+      const { items } = await ctx.$app.collections[sealious_field.target_collection].list(ctx.$context).fetch();
+      return items.map((s) => ({
+        label: this.item_label_getter(s),
+        value: s.id
+      }));
+    });
+    this.sealious_field = sealious_field;
+    this.item_label_getter = (item) => item.get("name");
+  }
+  setItemLabelGetter(getter) {
+    this.item_label_getter = getter;
+  }
+  getSealiousCreateValue() {
+    throw new Error(
+      "This field is not set directly through field value, but instead relies on postSealiousCreate and postSealiousEdit"
+    );
+  }
+  async postSealiousCreate(ctx, created_item, form_data) {
+    const { items: existing_links } = await ctx.$app.collections[this.sealious_field.intermediary_collection].list(ctx.$context).filter({
+      [this.sealious_field.referencing_field]: created_item.id
+    }).fetch();
+    const { parsed: value } = await this.getParsedValue(
+      ctx,
+      form_data.raw_values,
+      false
+    );
+    const should_exist_ids = Object.entries(value || {}).filter(([, value2]) => value2 === "on").map(([key]) => key);
+    const to_delete = existing_links.filter(
+      (link) => !should_exist_ids.includes(
+        link.get(
+          this.sealious_field.intermediary_field_that_points_there
+        )
+      )
+    );
+    const to_create_ids = should_exist_ids.filter(
+      (id) => !existing_links.map(
+        (link) => (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          link.get(
+            this.sealious_field.intermediary_field_that_points_there
+          )
+        )
+      ).includes(id)
+    );
+    await Promise.all(
+      to_delete.map((item) => {
+        return item.remove(ctx.$context);
+      })
+    );
+    const promises = to_create_ids.map(async (id) => {
+      await this.sealious_field.getReferencingCollection().create(ctx.$context, {
+        [this.sealious_field.referencing_field]: created_item.id,
+        [this.sealious_field.intermediary_field_that_points_there]: id
+      });
+    });
+    await Promise.all(promises);
+  }
+  async postSealiousEdit(ctx, edited_item, value) {
+    return this.postSealiousCreate(ctx, edited_item, value);
+  }
+  async sealiousValueToForm(_ctx, value) {
+    return Object.fromEntries((value || []).map((id) => [id, "on"]));
+  }
+  generateFieldDeclaration(_field_info, vars) {
+    return `new ${vars.form_field_types}.${this.constructor.name}(${vars.sealious_field})`;
+  }
+  generateCreateValueGetter(field_info, vars) {
+    return `${wrapKeyName(
+      field_info.name
+    )}: undefined /* handled below in postSealiousCreate */`;
+  }
+}
+export {
+  DeepReverseSingleReferenceList
+};
+//# sourceMappingURL=deep-reverse-single-reference-list.js.map

package/lib/forms/fields/deep-reverse-single-reference-table.js

@@ -0,0 +1,122 @@
+import {
+  FieldTypes as SealiousFieldTypes
+} from "sealious";
+import { Boolean, TextBasedSimpleField } from "./fields.js";
+import { sealiousToFormField } from "./get-field-for-sealious.js";
+import { Table } from "./table.js";
+import { Table as TableControl } from "../controls/table.js";
+import { HiddenInput } from "../controls/hidden-input.js";
+function getReferencingFields(sealious_field) {
+  const referencing_collection = sealious_field.collection.app.collections[sealious_field.referencing_collection];
+  if (!referencing_collection) {
+    throw new Error(
+      "Unknown collection: " + sealious_field.referencing_collection
+    );
+  }
+  return referencing_collection.fields;
+}
+class DeepReverseSingleReferenceTable extends Table {
+  constructor(sealious_field) {
+    super({
+      selected: new Boolean(false),
+      [sealious_field.referencing_field]: new TextBasedSimpleField(true),
+      [sealious_field.intermediary_field_that_points_there]: new TextBasedSimpleField(true),
+      ...Object.fromEntries(
+        Object.values(getReferencingFields(sealious_field)).filter(
+          (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+        ).map((field) => [field.name, sealiousToFormField(field)])
+      )
+    });
+    this.sealious_field = sealious_field;
+  }
+  getControl() {
+    return new TableControl(this, {
+      label: this.name,
+      allow_adding: false,
+      subfield_controls: {
+        selected: this.columns.selected.getControl(),
+        [this.sealious_field.referencing_field]: new HiddenInput(
+          this.columns[this.sealious_field.referencing_field]
+        ),
+        [this.sealious_field.intermediary_field_that_points_there]: new HiddenInput(
+          this.columns[this.sealious_field.intermediary_field_that_points_there]
+        ),
+        ...Object.fromEntries(
+          Object.values(getReferencingFields(this.sealious_field)).filter(
+            (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+          ).map((field) => [
+            field.name,
+            this.columns[field.name].getControl()
+          ])
+        )
+      }
+    });
+  }
+  getSealiousCreateValue(_fctx) {
+    throw new Error("Method not implemented.");
+  }
+  async postSealiousCreate(ctx, created_item, form_data) {
+    const { items: to_delete } = await ctx.$app.collections["${toKebabCase(referencing_collection)}"].list(ctx.$context).filter({ "${referencing_field}": created_item.id }).fetch();
+    await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+    const referencing_fields = getReferencingFields(this.sealious_field);
+    const { parsed: value } = await this.getParsedValue(
+      ctx,
+      form_data.raw_values,
+      false
+    );
+    const promises = (value || []).filter((s) => s.selected == true).map(async (link_info) => {
+      await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(ctx.$context, {
+        "${referencing_field}": created_item.id,
+        "${intermediary_field_that_points_there}": String(
+          link_info["${intermediary_field_that_points_there}"]
+        ),
+        ...Object.fromEntries(
+          Object.values(referencing_fields).filter(
+            (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+          ).map((field) => [field.name, link_info[field.name]])
+        )
+      });
+    });
+    await Promise.all(promises);
+  }
+  postSealiousEdit(ctx, edited_item, form_data) {
+    return this.postSealiousCreate(ctx, edited_item, form_data);
+  }
+  async sealiousValueToForm(ctx, _value, item) {
+    const referencing_fields = getReferencingFields(this.sealious_field);
+    return Object.fromEntries(
+      await Promise.all([
+        this.sealious_field.collection.list(ctx.$context).fetch(),
+        this.sealious_field.getReferencingCollection().list(ctx.$context).fetch()
+      ]).then(
+        ([{ items: targets }, { items: links }]) => targets.map((target) => {
+          return {
+            selected: (item.get(
+              this.sealious_field.name
+            ) || []).includes(target.id) ? "on" : "off",
+            [this.sealious_field.referencing_field]: item.id,
+            [this.sealious_field.intermediary_field_that_points_there]: target.id,
+            ...Object.fromEntries(
+              Object.values(referencing_fields).filter(
+                (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+              ).map((field) => [
+                field.name,
+                links.find(
+                  (e) => e.get(
+                    this.sealious_field.intermediary_field_that_points_there
+                  ) == target.id && e.get(
+                    this.sealious_field.referencing_field
+                  ) == item.id
+                )?.get("rank") || 0
+              ])
+            )
+          };
+        }).entries()
+      )
+    );
+  }
+}
+export {
+  DeepReverseSingleReferenceTable
+};
+//# sourceMappingURL=deep-reverse-single-reference-table.js.map

package/lib/forms/fields/email.js

@@ -1,5 +1,6 @@
 import { predicates } from "@sealcode/ts-predicates";
 import { RegExpField } from "./regexp.js";
+import { SimpleInput } from "../controls/controls.js";
 class EmailField extends RegExpField {
   constructor(required, error_message = "Please enter a proper email address", default_value = "") {
     super(
@@ -12,6 +13,12 @@ class EmailField extends RegExpField {
     this.default_value = default_value;
     this.predicate = predicates.string;
   }
+  setErrorMessage(message) {
+    this.error_message = message;
+  }
+  getControl() {
+    return new SimpleInput(this, { label: this.name, type: "email" });
+  }
 }
 export {
   EmailField

package/lib/forms/fields/enum-multiple-sealious.js

@@ -0,0 +1,32 @@
+import { CheckboxedListField } from "./checkboxed-list.js";
+class EnumMultipleSealious extends CheckboxedListField {
+  constructor(sealious_field) {
+    super(
+      sealious_field.required,
+      async (ctx) => (await sealious_field.getAllowedValues(ctx.$context)).map(
+        (value) => ({ value, label: value })
+      )
+    );
+    this.sealious_field = sealious_field;
+  }
+  generateFieldDeclaration(field_info, vars) {
+    return `new ${vars.form_field_types}.${this.constructor.name}(${vars.sealious_field})`;
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    const result = Object.entries(parsed || {}).filter(([, value]) => value == "on").map(([key]) => key);
+    return result;
+  }
+  async sealiousValueToForm(ctx, sealious_value) {
+    return Object.fromEntries(
+      (sealious_value || []).map((key) => [key, "on"])
+    );
+  }
+}
+export {
+  EnumMultipleSealious
+};
+//# sourceMappingURL=enum-multiple-sealious.js.map

package/lib/forms/fields/field.js

@@ -1,5 +1,6 @@
 import { predicates } from "@sealcode/ts-predicates";
 import { t } from "../../utils/translate.js";
+import { wrapAttribute, wrapKeyName } from "../../utils/wrap-attributes.js";
 function fieldsToShape(obj) {
   return Object.fromEntries(
     Object.entries(obj).map(([key, value]) => [key, value.predicate])
@@ -11,8 +12,11 @@ class FormField {
     this.predicate = predicates.unknown;
     this.mapToFilter = (value) => value;
   }
-  async init(fieldname) {
-    this.name = fieldname;
+  async init() {
+  }
+  setName(name) {
+    this.name = name;
+    return this;
   }
   async _validate(ctx, value) {
     if (value === "" || value === null || value === void 0) {
@@ -38,7 +42,7 @@ class FormField {
   async isValueValid(_ctx, _value) {
     return { valid: true, message: "" };
   }
-  async getValue(ctx, all_form_values, validate = false) {
+  async getParsedValue(ctx, all_form_values, validate = false) {
     const raw = all_form_values[this.name];
     if (raw == void 0 || raw == null || raw == "") {
       return {
@@ -79,9 +83,33 @@ class FormField {
   }
   //return undefined here to delete a value
   async getDatabaseValue(ctx, data) {
-    const { parsed } = await this.getValue(ctx, data);
+    const { parsed } = await this.getParsedValue(ctx, data);
     return parsed;
   }
+  getSealiousCreateValue(fctx) {
+    throw new Error("This field does not have a default sealious mapping");
+  }
+  sealiousValueToForm(ctx, sealiousValue, item) {
+    throw new Error("This field does not have a default sealious mapping");
+  }
+  async postSealiousCreate(ctx, created_item, form_data) {
+  }
+  async postSealiousEdit(ctx, edited_item, form_data) {
+  }
+  generateFieldDeclaration(field_info, vars) {
+    return `new ${vars.form_field_types}.${this.constructor.name}(${String(
+      field_info.is_required
+    )})`;
+  }
+  generateCreateValueGetter(field_info, vars) {
+    return `${wrapKeyName(field_info.name)}: await ${vars.form_fields}${wrapAttribute(field_info.name)}.getSealiousCreateValue(fctx)`;
+  }
+  generateInitialValue(field_info, vars) {
+    return `${wrapKeyName(field_info.name)}: await ${vars.form_fields}${wrapAttribute(field_info.name)}.sealiousValueToForm(ctx, item.get("${field_info.name}"))`;
+  }
+  generateImportsForFieldList(field_info) {
+    return [];
+  }
 }
 export {
   FormField,

package/lib/forms/fields/field.test.js

@@ -5,7 +5,7 @@ import { mount } from "../../mount.js";
 import { Form } from "../form.js";
 import { getBrowser } from "../../utils/browser-creator.js";
 import assert from "assert";
-import { SimpleFormField } from "./simple-form-field.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
 import { SimpleInput } from "../controls/simple-input.js";
 import { Boolean } from "./boolean.js";
 import { Checkbox } from "../controls/checkbox.js";
@@ -23,7 +23,7 @@ describe("basic field", () => {
       const app = new Koa();
       const router = new Router();
       const fields = {
-        text: new SimpleFormField(true)
+        text: new TextBasedSimpleField(true)
       };
       let received_values;
       mount(
@@ -37,7 +37,7 @@ describe("basic field", () => {
           }
           async onSubmit(ctx, data) {
             received_values = await this.getParsedValues(ctx);
-            const { parsed: email } = await this.fields.text.getValue(
+            const { parsed: email } = await this.fields.text.getParsedValue(
               ctx,
               data.raw_values
             );
@@ -64,7 +64,7 @@ describe("basic field", () => {
       let is_value_valid_called = false;
       let parse_called = false;
       const fields = {
-        text: new class MockField extends SimpleFormField {
+        text: new class MockField extends TextBasedSimpleField {
           async isValueValid() {
             is_value_valid_called = true;
             return true;
@@ -109,7 +109,7 @@ describe("basic field", () => {
       const router = new Router();
       let submit_called = false;
       const fields = {
-        text: new SimpleFormField(false),
+        text: new TextBasedSimpleField(false),
         checkbox: new Boolean(false)
       };
       mount(

package/lib/forms/fields/fields.js

@@ -1,17 +1,32 @@
-export * from "./simple-form-field.js";
+export * from "./boolean.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 "./color.js";
+export * from "./coordinates.js";
+export * from "./date.js";
+export * from "./datetime.js";
+export * from "./deep-reverse-single-reference-list.js";
+export * from "./deep-reverse-single-reference-table.js";
 export * from "./email.js";
-export * from "./enum.js";
-export * from "./boolean.js";
-export * from "./enum-multiple.js";
+export * from "./enum-multiple-sealious.js";
 export * from "./existing-sealious-value.js";
 export * from "./file.js";
+export * from "./float.js";
+export * from "./html.js";
+export * from "./image.js";
+export * from "./int.js";
+export * from "./json.js";
+export * from "./markdown.js";
 export * from "./multiple-files.js";
-export * from "./reverse-single-reference.js";
+export * from "./number.js";
+export * from "./password.js";
+export * from "./pick-from-list-sealious.js";
+export * from "./pick-from-list.js";
+export * from "./regexp.js";
+export * from "./simple-form-field.js";
+export * from "./single-reference.js";
 export * from "./structured-array.js";
 export * from "./table.js";
+export * from "./text.js";
+export * from "./url.js";
 //# sourceMappingURL=fields.js.map

package/lib/forms/fields/file.js

@@ -1,18 +1,16 @@
 import { hasFieldOfType, is, predicates } from "@sealcode/ts-predicates";
-import {
-  PathFilePointer
-} from "@sealcode/file-manager";
+import { PathFilePointer } from "@sealcode/file-manager";
 import { FormField } from "./field.js";
+import { File as FileControl } from "../controls/file.js";
 class File extends FormField {
-  constructor(required, file_manager) {
+  constructor(required) {
     super(required);
     this.required = required;
-    this.file_manager = file_manager;
   }
-  async parse(_ctx, raw_value) {
+  async parse(ctx, raw_value) {
     let result;
     if (is(raw_value, predicates.string)) {
-      const file = await this.file_manager.fromToken(raw_value);
+      const file = await ctx.$app.fileManager.fromToken(raw_value);
       result = {
         parsed_value: { old: file, new: null },
         error: null,
@@ -29,7 +27,7 @@ class File extends FormField {
         raw_value,
         "old",
         predicates.instanceOf(PathFilePointer)
-      ) ? await this.file_manager.toPointer(
+      ) ? await ctx.$app.fileManager.toPointer(
         raw_value.old
       ) : null;
       const new_file = hasFieldOfType(
@@ -49,12 +47,38 @@ class File extends FormField {
     return result;
   }
   async getDatabaseValue(ctx, data) {
-    const { parsed } = await this.getValue(ctx, data);
+    const { parsed } = await this.getParsedValue(ctx, data);
     return parsed?.new || void 0;
   }
   getEmptyValue() {
     return { old: null, new: null };
   }
+  getControl(...args) {
+    return new FileControl(this, { label: this.name, autocomplete: false });
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed: value } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    const pointer = value?.new || value?.old || void 0;
+    if (this.required && !pointer) {
+      throw new Error("File is required, but no value is provided");
+    }
+    return pointer;
+  }
+  async sealiousValueToForm(ctx, sealiousValue) {
+    if (!sealiousValue) {
+      return {};
+    }
+    if (typeof sealiousValue == "string") {
+      sealiousValue = await ctx.$app.fileManager.fromToken(sealiousValue);
+    }
+    return {
+      old: sealiousValue
+      // FilePointer
+    };
+  }
 }
 export {
   File

package/lib/forms/fields/file.test.js

@@ -1,11 +1,10 @@
 import Router from "@koa/router";
-import { FileManager, FilePointer } from "@sealcode/file-manager";
+import { FilePointer } from "@sealcode/file-manager";
 import getPort from "get-port";
 import Koa from "koa";
 import fs from "node:fs/promises";
-import { KoaResponsiveImageRouter } from "koa-responsive-image-router";
 import { mount } from "../../mount.js";
-import { Photo } from "../controls/photo.js";
+import { Image } from "../controls/image.js";
 import { Form } from "../form.js";
 import { File as FileField } from "./file.js";
 import { getBrowser } from "../../utils/browser-creator.js";
@@ -26,7 +25,7 @@ describe("file field", () => {
     const app = new Koa();
     const router = new Router();
     const fields = {
-      file: new FileField(true, new FileManager("/tmp", "/uploaded_files"))
+      file: new FileField(true)
     };
     let received_values;
     mount(
@@ -36,18 +35,7 @@ describe("file field", () => {
         constructor() {
           super(...arguments);
           this.fields = fields;
-          this.controls = [
-            new Photo(
-              fields.file,
-              new KoaResponsiveImageRouter({
-                staticPath: "/tmp",
-                thumbnailSize: 10,
-                cacheManagerResolutionThreshold: 10,
-                imageStoragePath: "/tmp",
-                smartCropStoragePath: "/tmp"
-              })
-            )
-          ];
+          this.controls = [new Image(fields.file)];
         }
         async onSubmit(ctx) {
           received_values = await this.getParsedValues(ctx);

package/lib/forms/fields/float.js

@@ -0,0 +1,10 @@
+import { NumberBasedSimpleField } from "./simple-form-field.js";
+class Float extends NumberBasedSimpleField {
+  constructor(required) {
+    super(required, "number");
+  }
+}
+export {
+  Float
+};
+//# sourceMappingURL=float.js.map