@sealcode/sealgen 0.18.10 → 0.19.2

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";
@@ -19,11 +19,11 @@ describe("basic field", () => {
     });
     it("sends the values", async () => {
       const port = await getPort();
-      console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+      console.info(`Using port ${port} form checkboxed-list-input.test.ts`);
       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
             );
@@ -58,13 +58,13 @@ describe("basic field", () => {
     });
     it("Doesn't call `isValueValid` and `parse` if the value is empty", async () => {
       const port = await getPort();
-      console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+      console.info(`Using port ${port} form checkboxed-list-input.test.ts`);
       const app = new Koa();
       const router = new Router();
       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;
@@ -104,12 +104,12 @@ describe("basic field", () => {
     });
     it("Accepts a form where non-required values are empty", async () => {
       const port = await getPort();
-      console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+      console.info(`Using port ${port} form checkboxed-list-input.test.ts`);
       const app = new Koa();
       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() {
+    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";
@@ -22,11 +21,11 @@ describe("file field", () => {
   });
   it("should handle as imple upload scenario", async () => {
     const port = await getPort();
-    console.log(`Using port http://localhost:${port} form file field test`);
+    console.info(`Using port http://localhost:${port} form file field test`);
     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

package/lib/forms/fields/get-field-for-sealious.js

@@ -0,0 +1,213 @@
+import {
+  FieldTypes as SealiousFieldTypes
+} from "sealious";
+import { Boolean as BooleanField } from "./boolean.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+import { File } from "./file.js";
+import { StructuredArray as StructuredArrayField } from "./structured-array.js";
+import { Color } from "./color.js";
+import { DateField } from "./date.js";
+import { DateTime } from "./datetime.js";
+import { EmailField } from "./email.js";
+import { Float } from "./float.js";
+import { HTML } from "./html.js";
+import { Int } from "./int.js";
+import { JSONField } from "./json.js";
+import { Password } from "./password.js";
+import { Text } from "./text.js";
+import { Markdown } from "./markdown.js";
+import { DeepReverseSingleReferenceTable } from "./deep-reverse-single-reference-table.js";
+import { DeepReverseSingleReferenceList } from "./deep-reverse-single-reference-list.js";
+import { Coordinates } from "./coordinates.js";
+import { PickFromListSealious } from "./pick-from-list-sealious.js";
+import { SingleReference } from "./single-reference.js";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
+import { EnumMultipleSealious } from "./enum-multiple-sealious.js";
+import { URLField } from "./url.js";
+import { Image } from "./image.js";
+function sealiousToFormField(sealious_field) {
+  if (sealious_field instanceof SealiousFieldTypes.Boolean) {
+    return new BooleanField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Color) {
+    return new Color(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.ControlAccess) {
+    const target_field = sealious_field.virtual_field;
+    return sealiousToFormField(target_field);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Date) {
+    return new DateField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.DateTime) {
+    return new DateTime(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.DeepReverseSingleReference) {
+    const referencing_collection = sealious_field.collection.app.collections[sealious_field.referencing_collection];
+    if (!referencing_collection) {
+      throw new Error(
+        "Unknown collection: " + sealious_field.referencing_collection
+      );
+    }
+    if (Object.keys(referencing_collection.fields).length == 2) {
+      return new DeepReverseSingleReferenceList(
+        sealious_field
+      );
+    } else {
+      return new DeepReverseSingleReferenceTable(
+        sealious_field
+      );
+    }
+  }
+  if (sealious_field instanceof SealiousFieldTypes.DisallowUpdate) {
+    return sealiousToFormField(
+      sealious_field.virtual_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Email) {
+    return new EmailField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Enum) {
+    return new PickFromListSealious(
+      sealious_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.EnumMultiple) {
+    return new EnumMultipleSealious(
+      sealious_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.File) {
+    return new File(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Float) {
+    return new Float(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.HTML) {
+    return new HTML(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Image) {
+    return new Image(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Int) {
+    return new Int(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.JsonObject) {
+    return new JSONField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Password) {
+    return new Password(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.SettableBy) {
+    return sealiousToFormField(
+      sealious_field.virtual_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.SingleReference) {
+    return new SingleReference(
+      false,
+      sealious_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Text) {
+    return new Text(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Username) {
+    return new Text(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Url) {
+    return new URLField(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Money) {
+    return new Float(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Markdown) {
+    return new Markdown(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Coordinates) {
+    return new Coordinates(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.StructuredArray) {
+    return new StructuredArrayField(
+      sealious_field
+    );
+  }
+  return new TextBasedSimpleField(false);
+}
+async function sealiousFieldInfoToFormField(field_info) {
+  switch (field_info.type) {
+    case "boolean":
+      return new BooleanField(field_info.is_required);
+    case "color":
+      return new Color(field_info.is_required);
+    case "date":
+      return new DateField(field_info.is_required);
+    case "datetime":
+      return new DateTime(field_info.is_required);
+    case "deep-reverse-single-reference": {
+      const referencing_fields = await extract_fields_from_collection(
+        field_info.referencing_collection
+      );
+      if (referencing_fields.length == 2) {
+        return new DeepReverseSingleReferenceList({});
+      } else {
+        return new DeepReverseSingleReferenceTable({});
+      }
+    }
+    case "email":
+      return new EmailField(field_info.is_required);
+    case "enum":
+      return new PickFromListSealious({});
+    case "enum-multiple":
+      return new EnumMultipleSealious({});
+    case "file":
+      return new File(field_info.is_required);
+    case "float":
+      return new Float(field_info.is_required);
+    case "html":
+      return new HTML(field_info.is_required);
+    case "image":
+      return new Image(field_info.is_required);
+    case "int":
+      return new Int(field_info.is_required);
+    case "json-object":
+      return new JSONField(field_info.is_required);
+    case "password":
+      return new Password(field_info.is_required);
+    case "single-reference":
+      return new SingleReference(false, {});
+    case "text":
+      return new Text(field_info.is_required);
+    case "username":
+      return new Text(field_info.is_required);
+    case "url":
+      return new URLField(field_info.is_required);
+    case "money":
+      return new Float(field_info.is_required);
+    case "markdown":
+      return new Markdown(field_info.is_required);
+    case "coordinates":
+      return new Coordinates(field_info.is_required);
+    case "structured-array":
+      return new StructuredArrayField(
+        new SealiousFieldTypes.StructuredArray({})
+      );
+    default:
+      return new TextBasedSimpleField(false);
+  }
+}
+export {
+  sealiousFieldInfoToFormField,
+  sealiousToFormField
+};
+//# sourceMappingURL=get-field-for-sealious.js.map

package/lib/forms/fields/html.js

@@ -0,0 +1,14 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class HTML extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "text");
+  }
+  getControl() {
+    return new Textarea(this);
+  }
+}
+export {
+  HTML
+};
+//# sourceMappingURL=html.js.map

package/lib/forms/fields/image.js

@@ -0,0 +1,13 @@
+import { Image as ImageControl } from "../controls/image.js";
+import { File as FileField } from "./file.js";
+class Image extends FileField {
+  getControl() {
+    return new ImageControl(
+      this
+    );
+  }
+}
+export {
+  Image
+};
+//# sourceMappingURL=image.js.map

package/lib/forms/fields/int.js

@@ -0,0 +1,23 @@
+import { NumberBasedSimpleField } from "./simple-form-field.js";
+class Int extends NumberBasedSimpleField {
+  constructor(required) {
+    super(required, "number");
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    if (parsed == null) {
+      return void 0;
+    }
+    if (isNaN(parsed)) {
+      return void 0;
+    } else
+      return parsed;
+  }
+}
+export {
+  Int
+};
+//# sourceMappingURL=int.js.map

package/lib/forms/fields/json.js

@@ -0,0 +1,31 @@
+import { Textarea } from "../controls/textarea.js";
+import { SimpleFormField } from "./simple-form-field.js";
+class JSONField extends SimpleFormField {
+  constructor(required) {
+    super(required, "text");
+  }
+  getControl() {
+    return new Textarea(this);
+  }
+  getEmptyValue() {
+    return {};
+  }
+  async parse(ctx, raw_value) {
+    return {
+      parsable: true,
+      error: null,
+      parsed_value: JSON.parse(raw_value)
+    };
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed;
+  }
+}
+export {
+  JSONField
+};
+//# sourceMappingURL=json.js.map

package/lib/forms/fields/markdown.js

@@ -0,0 +1,14 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class Markdown extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "text");
+  }
+  getControl() {
+    return new Textarea(this);
+  }
+}
+export {
+  Markdown
+};
+//# sourceMappingURL=markdown.js.map

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

@@ -1,4 +1,5 @@
 import { FormField } from "./field.js";
+import { MultipleFiles as MultipleFilesControl } from "../controls/multiple-files.js";
 class MultipleFiles extends FormField {
   constructor(collection_field, getItemId) {
     super(false);
@@ -11,6 +12,9 @@ class MultipleFiles extends FormField {
   async parse() {
     return { parsed_value: void 0, parsable: true, error: null };
   }
+  getControl() {
+    return new MultipleFilesControl(this);
+  }
 }
 export {
   MultipleFiles

package/lib/forms/fields/number.js

@@ -1,4 +1,5 @@
 import { is, predicates } from "@sealcode/ts-predicates";
+import { SimpleInput } from "../controls/simple-input.js";
 import { FormField } from "./field.js";
 class NumberField extends FormField {
   constructor(required, default_value, options = {}) {
@@ -35,6 +36,11 @@ class NumberField extends FormField {
   getEmptyValue() {
     return this.default_value;
   }
+  getControl() {
+    return new SimpleInput(this, {
+      type: "number"
+    });
+  }
 }
 export {
   NumberField

package/lib/forms/fields/password.js

@@ -0,0 +1,13 @@
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class Password extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "password");
+  }
+  async sealiousValueToForm() {
+    return void 0;
+  }
+}
+export {
+  Password
+};
+//# sourceMappingURL=password.js.map

package/lib/forms/fields/pick-from-list-sealious.js

@@ -0,0 +1,17 @@
+import { PickFromListField } from "./pick-from-list.js";
+class PickFromListSealious extends PickFromListField {
+  constructor(sealious_field) {
+    super(
+      sealious_field.required,
+      async (ctx) => sealious_field.getAllowedValues(ctx.$app).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})`;
+  }
+}
+export {
+  PickFromListSealious
+};
+//# sourceMappingURL=pick-from-list-sealious.js.map