@sealcode/sealgen 0.15.33 → 0.15.35

package/@types/src/forms/controls/controls.d.ts

@@ -28,3 +28,4 @@ export * from "./multiple-files.js";
 export * from "./number.js";
 export * from "./multiple-photos.js";
 export * from "./array.js";
+export * from "./table.js";

package/@types/src/forms/controls/table.d.ts

@@ -0,0 +1,15 @@
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { Table as TableField } from "../fields/table.js";
+import { FormControl, FormControlContext } from "./form-control.js";
+export declare class Table<F extends Record<string, FormField>> extends FormControl {
+    table_field: TableField<F>;
+    render_fields: {
+        [field_name in keyof F]: (fctx: FormControlContext, name: string, value: string) => string;
+    };
+    role: "input";
+    constructor(table_field: TableField<F>, render_fields: {
+        [field_name in keyof F]: (fctx: FormControlContext, name: string, value: string) => string;
+    });
+    render(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

package/@types/src/forms/fields/fields.d.ts

@@ -13,3 +13,4 @@ export * from "./file.js";
 export * from "./multiple-files.js";
 export * from "./reverse-single-reference.js";
 export * from "./structured-array.js";
+export * from "./table.js";

package/@types/src/forms/fields/table.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export type TableFieldParsed<F extends Record<string, FormField>> = {
+    [field_name in keyof F]: unknown;
+}[];
+export declare class Table<F extends Record<string, FormField>> extends FormField<true, TableFieldParsed<F>> {
+    columns: F;
+    constructor(columns: F);
+    getEmptyValue(): never[];
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<TableFieldParsed<F>>>;
+}

package/@types/src/templates/shared/collection-create-form.d.ts

@@ -1 +1,3 @@
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+export declare function renderFieldForSealious({ name, type, is_required, is_readonly, }: ExtractedFieldInfo): string;
 export declare function createItemFormTemplate(create_action_name: string, newfilefullpath: string, collection_name: string, list_action: string): Promise<string>;

package/@types/src/templates/shared/collection-edit-form.d.ts

@@ -0,0 +1 @@
+export declare function editItemFormTemplate(edit_action_name: string, newfilefullpath: string, collection_name: string, list_action: string): Promise<string>;

package/@types/src/templates/shared/collection-list.d.ts

@@ -10,6 +10,7 @@ declare const default_hooks: {
     pre_header_html: string;
     post_header_html: string;
     post_import_js: string;
+    render_item: (collection_name: string) => string;
 };
 export declare function collectionListTemplate(collection_name: string, action_name: string, newfilefullpath: string, _hooks?: Partial<typeof default_hooks>): Promise<string>;
 export {};

package/@types/src/templates/shared/confirm-item-delete.d.ts

@@ -0,0 +1 @@
+export declare function askItemDeleteTemplate(ask_delete_action_name: string, collection_name: string, newfilefullpath: string, list_action_name: string, delete_action_name: string): Promise<string>;

package/@types/src/templates/shared/item-delete.d.ts

@@ -0,0 +1 @@
+export declare function itemDeleteTemplate(delete_action_name: string, collection_name: string, newfilefullpath: string, list_action_name: string): Promise<string>;

package/@types/src/templates/shared/shared-crud-form-fields.d.ts

@@ -1 +1,45 @@
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+type FieldHandlerResult = {
+    imports: Partial<{
+        shared: string;
+        edit: string;
+    }>;
+    field: string;
+    controls: string;
+    is_required: boolean;
+    is_required_expr: string;
+    fields_var: string;
+    top_level_shared: string;
+    name: string;
+    initial_value: Partial<{
+        main_value: string;
+        parsed_value: string;
+        fallback_value: string;
+    }> | string;
+    post_edit: string;
+};
+type FieldHandler<Defaults extends Partial<FieldHandlerResult>, Result extends Partial<FieldHandlerResult>> = (collection_name: string, field: ExtractedFieldInfo, importPath: (path: string) => string, defaults: Defaults) => Promise<Result>;
+export declare const field_handlers: Record<string, FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>> | undefined> & {
+    default: FieldHandler<Record<string, never>, FieldHandlerResult>;
+};
+export declare function getFieldHandler(collection_name: string, field: ExtractedFieldInfo, importPath: (path: string) => string): Promise<{
+    imports: Partial<{
+        shared: string;
+        edit: string;
+    }>;
+    field: string;
+    controls: string;
+    is_required: boolean;
+    is_required_expr: string;
+    fields_var: string;
+    top_level_shared: string;
+    name: string;
+    initial_value: string | Partial<{
+        main_value: string;
+        parsed_value: string;
+        fallback_value: string;
+    }>;
+    post_edit: string;
+}>;
 export declare function sharedCrudFormFields(collection_name: string, newfilefullpath: string): Promise<string>;
+export {};

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

@@ -14,3 +14,4 @@ export * from "./make-slug.js";
 export * from "./render-attributes.js";
 export * from "./format-external-url.js";
 export * from "./base64.js";
+export * from "./with-fallback.js";

package/@types/src/utils/with-fallback.d.ts

@@ -0,0 +1,2 @@
+export declare function withFallback<T1, T2 extends NonNullable<unknown>>(value1: T1, value2: T2): NonNullable<T1> | T2;
+export declare function withFallback<T1, T2, T3 extends NonNullable<unknown>>(value1: T1, value2: T2, value3?: T3): NonNullable<T1> | NonNullable<T2> | T3;

package/lib/add-crud.js

@@ -0,0 +1,131 @@
+import _locreq from "locreq";
+import { escape_url_params } from "./utils/escape-url-params.js";
+import prompts from "prompts";
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { listCollections } from "./utils/list-collections.js";
+import { collectionListTemplate } from "./templates/shared/collection-list.js";
+import { writeFile } from "./utils/write-file.js";
+import { importPath } from "./utils/import-path.js";
+import { sharedCrudFormFields } from "./templates/shared/shared-crud-form-fields.js";
+import { generateRoutes } from "./generate-routes.js";
+import { createItemFormTemplate } from "./templates/shared/collection-create-form.js";
+import { editItemFormTemplate } from "./templates/shared/collection-edit-form.js";
+import { askItemDeleteTemplate } from "./templates/shared/confirm-item-delete.js";
+import { itemDeleteTemplate } from "./templates/shared/item-delete.js";
+async function addCRUD(params, app_directory = process.cwd()) {
+  const target_locreq = _locreq(app_directory);
+  prompts.override(params);
+  const response = await prompts([
+    {
+      type: "autocomplete",
+      name: "collection",
+      message: "Which sealious collection do you like to add CRUD forms for?",
+      choices: (await listCollections()).map((collection) => ({
+        title: collection,
+        value: collection
+      }))
+    },
+    {
+      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 '/'",
+      initial: function(_, { collection }) {
+        return "/" + toKebabCase(collection);
+      }
+    }
+  ]);
+  const collection_name = response.collection;
+  const url = response.url;
+  const list_action_name = toPascalCase(collection_name) + "List";
+  const create_action_name = toPascalCase(collection_name) + "Create";
+  const edit_action_name = toPascalCase(collection_name) + "Edit";
+  const delete_ask_action_name = toPascalCase(collection_name) + "DeleteAsk";
+  const delete_action_name = toPascalCase(collection_name) + "Delete";
+  const list_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}.list.tsx`
+  );
+  const list_content = await collectionListTemplate(
+    collection_name,
+    list_action_name,
+    list_path,
+    {
+      post_import_js: `import { ${create_action_name}URL, ${edit_action_name}URL, ${delete_ask_action_name}URL } from "${importPath(
+        list_path,
+        "src/back/routes/urls.ts"
+      )}";`,
+      post_header_html: `<a href={${create_action_name}URL}> Create </a>`,
+      render_item: (collection_name2) => `	async renderItem(ctx: Context, item: CollectionItem<typeof ${toPascalCase(
+        collection_name2
+      )}>) {
+					   return <tr>
+						   {displayFields.map(({ field, format }) => {
+							   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+							   const value = item.get(field as any);
+							   return <td>{format ? format(value, item) : value}</td>;
+						   })}
+                           <td><div class="sealious-list__actions">
+                               <a href={${edit_action_name}URL(item.id)}>Edit</a>
+                               <a href={${delete_ask_action_name}URL(item.id)}>Delete</a>
+                               </div>
+                           </td>
+					   </tr>;
+				   }`
+    }
+  );
+  await writeFile(list_path, list_content);
+  const fields_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/shared.ts`
+  );
+  const fields_content = await sharedCrudFormFields(
+    collection_name,
+    fields_path
+  );
+  await writeFile(fields_path, fields_content);
+  const create_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/create.form.ts`
+  );
+  const create_content = await createItemFormTemplate(
+    create_action_name,
+    create_path,
+    collection_name,
+    list_action_name
+  );
+  await writeFile(create_path, create_content);
+  const edit_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/[id]/edit.form.ts`
+  );
+  const edit_content = await editItemFormTemplate(
+    edit_action_name,
+    edit_path,
+    collection_name,
+    list_action_name
+  );
+  await writeFile(edit_path, edit_content);
+  const delete_ask_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/[id]/delete-ask.page.tsx`
+  );
+  const delete_ask_content = await askItemDeleteTemplate(
+    delete_ask_action_name,
+    collection_name,
+    delete_ask_path,
+    list_action_name,
+    delete_action_name
+  );
+  await writeFile(delete_ask_path, delete_ask_content);
+  const delete_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/[id]/delete.page.tsx`
+  );
+  const delete_content = await itemDeleteTemplate(
+    delete_action_name,
+    collection_name,
+    delete_ask_path,
+    list_action_name
+  );
+  await writeFile(delete_path, delete_content);
+  await generateRoutes();
+}
+export {
+  addCRUD
+};
+//# sourceMappingURL=add-crud.js.map

package/lib/forms/controls/controls.js

@@ -28,6 +28,7 @@ export * from "./multiple-files.js";
 export * from "./number.js";
 export * from "./multiple-photos.js";
 export * from "./array.js";
+export * from "./table.js";
 export {
   CheckboxedListInput,
   EditableCollectionSubset,

package/lib/forms/controls/table.js

@@ -0,0 +1,62 @@
+import { FormControl } from "./form-control.js";
+class Table extends FormControl {
+  constructor(table_field, render_fields) {
+    super();
+    this.table_field = table_field;
+    this.render_fields = render_fields;
+    this.role = "input";
+  }
+  async render(fctx) {
+    const { parsed: rows } = await this.table_field.getValue(
+      fctx.ctx,
+      fctx.data
+    );
+    if (!rows) {
+      return "";
+    }
+    return (
+      /* HTML */
+      `<div
+			class="${[
+        "form-input__wrapper",
+        "form-input__wrapper--type--table",
+        "form-input__wrapper--options-count--" + rows.length.toString(),
+        ...rows.length >= 5 ? ["form-input__wrapper--options-count--5-or-more"] : [],
+        ...rows.length >= 10 ? ["form-input__wrapper--options-count--10-or-more"] : [],
+        ...rows.length >= 15 ? ["form-input__wrapper--options-count--15-or-more"] : [],
+        ...rows.length >= 20 ? ["form-input__wrapper--options-count--20-or-more"] : []
+      ].join(" ")}"
+		>
+			<div class="table__wrapper">
+				<table>
+					<tbody>
+						<tr>
+							${rows?.map((row, row_index) => {
+        return (
+          /* HTML */
+          `<tr>
+										${Object.entries(
+            this.table_field.columns
+          ).map(([key]) => {
+            return `<td>${this.render_fields[key](
+              fctx,
+              `${this.table_field.name}[${row_index}][${key}]`,
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              row[key]
+            )}</td>`;
+          }).join("")}
+									</tr>`
+        );
+      }).join("")}
+						</tr>
+					</tbody>
+				</table>
+			</div>
+		</div>`
+    );
+  }
+}
+export {
+  Table
+};
+//# sourceMappingURL=table.js.map

package/lib/forms/fields/fields.js

@@ -13,4 +13,5 @@ export * from "./file.js";
 export * from "./multiple-files.js";
 export * from "./reverse-single-reference.js";
 export * from "./structured-array.js";
+export * from "./table.js";
 //# sourceMappingURL=fields.js.map

package/lib/forms/fields/table.js

@@ -0,0 +1,58 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+class Table extends FormField {
+  constructor(columns) {
+    super(true);
+    this.columns = columns;
+  }
+  getEmptyValue() {
+    return [];
+  }
+  async parse(ctx, raw_value) {
+    if (!is(raw_value, predicates.object)) {
+      return {
+        parsable: false,
+        error: "Expected an object",
+        parsed_value: null
+      };
+    }
+    const result = [];
+    for (const row_number in raw_value) {
+      const row_data = raw_value[row_number];
+      const parsed_row = {};
+      if (!is(row_data, predicates.object)) {
+        throw new Error(`Expected object, got ${String(row_data)}`);
+      }
+      for (const key in row_data) {
+        const field = this.columns[key];
+        if (field == void 0) {
+          return {
+            parsable: false,
+            error: `Unknown column: ${key}`,
+            parsed_value: null
+          };
+        }
+        const parse_result = await field.parse(
+          ctx,
+          row_data[key]
+        );
+        if (!parse_result.parsable) {
+          console.debug("table.ts:51");
+          return {
+            parsable: false,
+            error: `Invalid value for row ${row_number}.${key}: ${parse_result.error}`,
+            parsed_value: null
+          };
+        }
+        parsed_row[key] = parse_result.parsed_value;
+      }
+      result.push(parsed_row);
+    }
+    const ret = { parsed_value: result, parsable: true, error: null };
+    return ret;
+  }
+}
+export {
+  Table
+};
+//# sourceMappingURL=table.js.map

package/lib/templates/shared/collection-create-form.js

@@ -0,0 +1,146 @@
+import { toCamelCase, toKebabCase, toPascalCase } from "js-convert-case";
+import { formTemplate } from "../form.js";
+import { curryImportPath } from "../../utils/import-path.js";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
+function renderFieldForSealious({
+  name,
+  type,
+  is_required,
+  is_readonly
+}) {
+  if (type == "deep-reverse-single-reference" || type == "jdd" || is_readonly) {
+    return "";
+  }
+  let fallback_value = `""`;
+  let main_value = `data.${name}`;
+  if (type == "image" || type == "file") {
+    fallback_value = `null`;
+    if (is_required) {
+      main_value = toCamelCase("prepared-" + name);
+    }
+  }
+  if (type == "boolean") {
+    main_value = `!!data.${name}`;
+    fallback_value = "false";
+  }
+  if (type == "date") {
+    fallback_value == `undefined`;
+  }
+  if (is_required) {
+    return `${name}: ${main_value}`;
+  } else {
+    return `${name}: ${main_value} || ${fallback_value}`;
+  }
+}
+function renderFieldPreCreateAction({ name, type }) {
+  if (type == "image" || type == "file") {
+    const tempname = toCamelCase("prepared-" + name);
+    return `const ${tempname} = data.${name}.new || data.${name}.old;
+				if(!${tempname}){
+				    throw new Error("Missing field: ${name}")
+         		}`;
+  }
+  return "";
+}
+function renderFieldPostCreateAction({
+  name,
+  type,
+  referencing_collection,
+  referencing_field,
+  intermediary_field_that_points_there
+}) {
+  if (type == "deep-reverse-single-reference" && referencing_collection && referencing_field && intermediary_field_that_points_there) {
+    return ` await (async function(){
+            // We iterate over all selected values and insert appropriate entries for the ${name} relation
+			const ids = Object.entries(
+                           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                           data.${name} as unknown as Record<string, string>
+                        )
+                        .filter(([, value]) => value === "on")
+                        .map(([key]) => key);
+
+			const promises = ids.map(async (id) => {
+				await ctx.$app.collections["${referencing_collection}"].create(
+					new ctx.$app.SuperContext(),
+					{
+						"${referencing_field}": created.id,
+						"${intermediary_field_that_points_there}": id,
+					}
+				);
+			});
+
+			await Promise.all(promises);
+        })()`;
+  }
+  return "";
+}
+async function createItemFormTemplate(create_action_name, newfilefullpath, collection_name, list_action) {
+  const collection_fields = await extract_fields_from_collection(
+    collection_name
+  );
+  const importPath = curryImportPath(newfilefullpath);
+  return formTemplate(create_action_name, newfilefullpath, {
+    postimport: `import {${toPascalCase(
+      collection_name
+    )}FormFields, ${toPascalCase(
+      collection_name
+    )}FormControls }from "./shared.js";
+
+        import { ${toPascalCase(collection_name)} } from "${importPath(
+      "src/back/collections/collections.js"
+    )}";
+
+		import { ${list_action}URL } from "${importPath("src/back/routes/urls.js")}";
+
+        import {tempstream} from "tempstream";
+`,
+    fields: `...${toPascalCase(collection_name)}FormFields`,
+    controls: `
+                new Controls.FormHeader("Create ${toPascalCase(
+      collection_name
+    )}"), 
+                ...${toPascalCase(collection_name)}FormControls`,
+    can_access: `canAccess = async (ctx: Context) => {
+			 const policy = ${toPascalCase(collection_name)}.getPolicy("create");
+			 const response = await policy.check(ctx.$context);
+			 return { canAccess: response?.allowed || false, message: response?.reason || "" };
+		 };`,
+    onsubmit: `
+	async onSubmit(ctx: Context) {
+		const data = await this.getParsedValues(ctx);
+		if (!data) {
+			throw new Error("Error when parsing the form values");
+		}
+
+	   ${collection_fields.map((field) => renderFieldPreCreateAction(field)).filter((e) => e !== "").join("\n")}
+
+		const created = await ctx.$app.collections["${toKebabCase(
+      collection_name
+    )}"].create(
+			ctx.$context,
+			{
+				${collection_fields.map((field) => renderFieldForSealious(field)).filter((e) => e != "").join(",\n")}
+			}
+		);
+        ${collection_fields.map((field) => renderFieldPostCreateAction(field)).filter((e) => e != "").join("\n")}
+	}
+`,
+    render: `	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
+		return html(
+			ctx,
+			"AddBlogArticle",
+			tempstream/* HTML */ \` <div class="add-opinion-form">
+				<a class="" href="\${${list_action}URL}"
+					>\u2190 Back to ${collection_name} list</a
+				>
+				\${await super.render(ctx, data, show_field_errors)}
+			</div>\`
+		);
+	}`
+  });
+}
+export {
+  createItemFormTemplate,
+  renderFieldForSealious
+};
+//# sourceMappingURL=collection-create-form.js.map