@sealcode/sealgen 0.15.34 → 0.15.36

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

@@ -0,0 +1,157 @@
+import { 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";
+import { getFieldHandler } from "./shared-crud-form-fields.js";
+async function editItemFormTemplate(edit_action_name, newfilefullpath, collection_name, list_action) {
+  const collection_fields = await extract_fields_from_collection(
+    collection_name
+  );
+  const importPath = curryImportPath(newfilefullpath);
+  const field_handler_results = await Promise.all(
+    collection_fields.map(async (field) => {
+      return getFieldHandler(collection_name, field, importPath);
+    })
+  );
+  return formTemplate(edit_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, ${edit_action_name}URL } from "${importPath(
+      "src/back/routes/urls.js"
+    )}";
+                import {tempstream} from "tempstream";
+
+		${Array.from(
+      new Set(field_handler_results.map(({ imports }) => imports.edit))
+    ).join("\n")}
+
+        ${collection_fields.filter((e) => !e.is_required).length ? `import {withFallback} from "@sealcode/sealgen";` : ""}
+`,
+    fields: `...${toPascalCase(collection_name)}FormFields`,
+    controls: `
+                new Controls.FormHeader("Edit ${toPascalCase(
+      collection_name
+    )}"), 
+                ...${toPascalCase(collection_name)}FormControls`,
+    can_access: `canAccess = async (ctx: Context) => {
+			 const policy = ${toPascalCase(collection_name)}.getPolicy("edit");
+			 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);
+                const id = await this.getID(ctx);
+                const {items: [item]} = await ctx.$app.collections["${toKebabCase(
+      collection_name
+    )}"]
+                   .list(ctx.$context)
+                   .ids([id])
+                   .fetch();
+				if (!data) {
+					throw new Error("Error when parsing the form values");
+				}
+
+			   ${field_handler_results.map((result) => result.pre_edit).filter((e) => e !== "").join("\n")}
+
+				item.setMultiple(
+					{
+						${field_handler_results.filter((r) => !r.hide_sealious_value).map((result) => result.sealious_value(result)).filter((e) => e != "").join(",\n")}
+					}
+				);
+                await item.save(ctx.$context);
+
+                
+                ${field_handler_results.map((result) => result.post_edit).filter((e) => e != "").length ? `// #### POST-EDIT ACTIONS ############` : ""}
+                 ${field_handler_results.map((result) => result.post_edit).filter((e) => e != "").join("\n")}
+			}
+		`,
+    other_methods: `
+            async getID(ctx: Context): Promise<string>{
+               // trying to automatically guess which param is the one that represents the ID
+               // of the resource to edit. 
+               // If sealgen got it wrong, just return the param name that should be used here instead
+               const param_name = 
+                         ${edit_action_name}URL.params
+                         .find(param => param.toLowerCase().includes("id")) 
+                     || ${edit_action_name}URL.params[0]
+			   const id = ctx.params[param_name];
+	           if (!id) {
+				   throw new Error("Missing URL  parameter: " + param_name);
+			   }
+               return id
+            }
+        `,
+    get_initial_values: `async getInitialValues(ctx: Context) {
+               const id = await this.getID(ctx);
+
+               const {
+				   items: [item],
+			   } = await ctx.$app.collections["${toKebabCase(collection_name)}"]
+				   .list(ctx.$context)
+				   .ids([id])
+				   .attach({})
+				   .fetch();
+
+			   if (!item) {
+				   throw new Error("Item with given id not found: " + id);
+			   }
+
+			   return {
+				   ${field_handler_results.filter((r) => !r.hide_initial_value_edit).map(({ initial_value_edit, is_required, name }) => {
+      if (typeof initial_value_edit == "string") {
+        if (initial_value_edit == "") {
+          return "";
+        }
+        return `${name}: ${initial_value_edit}`;
+      }
+      const main_value = initial_value_edit.main_value;
+      if (!main_value) {
+        throw new Error(
+          "Missing main_value for initial_value_edit"
+        );
+      }
+      const { parsed_value, fallback_value } = initial_value_edit;
+      if (is_required) {
+        return `${name}: ${parsed_value || main_value}`;
+      }
+      if (main_value && parsed_value && fallback_value) {
+        if (main_value == parsed_value) {
+          return `${name}: withFallback(${main_value}, ${fallback_value})`;
+        } else {
+          return `${name}: withFallback(${main_value}, ${parsed_value}, ${fallback_value})`;
+        }
+      } else {
+        console.error(initial_value_edit);
+        throw new Error(
+          "Missing field info for generating initial value"
+        );
+      }
+    }).filter((e) => e.trim() !== "").join(",\n")}
+			   };
+		   }
+	   `,
+    render: `	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
+		return html(
+			ctx,
+			"Edit ${toPascalCase(collection_name)}",
+			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 {
+  editItemFormTemplate
+};
+//# sourceMappingURL=collection-edit-form.js.map

package/lib/templates/shared/collection-list.js

@@ -0,0 +1,226 @@
+import { extractCollectionClassname } from "../../generate-collections.js";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
+import _locreq from "locreq";
+import { curryImportPath } from "../../utils/import-path.js";
+import { DefaultListFilters } from "../../page/default-list-filters.js";
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { formatWithPrettier } from "../../utils/prettier.js";
+const target_locreq = _locreq(process.cwd());
+function fieldImport({ type }, importPath) {
+  if (type == "image") {
+    return `
+		import type { FilePointer } from "@sealcode/file-manager";
+		import { imageRouter } from "${importPath("src/back/image-router.js")}";
+	    `;
+  }
+  return "";
+}
+function makeDefaultFilterFields(collection_fields) {
+  return collection_fields.map(
+    (field) => `	{ field: "${field.name}", ...${DefaultListFilters[field.type] ? `DefaultListFilters["${field.type}"]` : `DefaultListFilters.fallback`} }`
+  ).join(",\n");
+}
+function makeDefaultDisplayFields(collection_fields) {
+  return collection_fields.map((field) => {
+    if (field.type == "boolean") {
+      return `	{
+		field: "${field.name}",
+		label: "${field.name}",
+		format: (v: boolean) => (v ? "YES" : "NO"),
+	}`;
+    }
+    if (field.type == "datetime") {
+      return `	{
+		field: "${field.name}",
+		label: "${field.name}",
+		format: (v: number) => {
+			const d = new Date();
+			d.setTime(v);
+			return d.toString().split(" ").slice(1, 5).join(" ");
+		},
+	}`;
+    }
+    if (field.type == "image") {
+      return `{
+					field: "${field.name}",
+					label: "${field.name}",
+					format: async (value: FilePointer) => {
+						return imageRouter.image(await value.getPath(), {
+							container: { width: 45, height: 45 },
+                            crop: { width: 45, height: 45 },
+							alt: "",
+						});
+					},
+				}`;
+    }
+    return `	{ field: "${field.name}", label: "${field.name}" }`;
+  }).join(",\n");
+}
+const default_hooks = {
+  pre_header_html: "",
+  post_header_html: "",
+  post_import_js: "",
+  render_item: (collection_name) => `	async renderItem(_ctx: Context, item: CollectionItem<typeof ${toPascalCase(
+    collection_name
+  )}>) {
+		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>;
+			})}
+		</tr>;
+    }`
+};
+async function collectionListTemplate(collection_name, action_name, newfilefullpath, _hooks = {}) {
+  const hooks = { ...default_hooks, ..._hooks };
+  const [uppercase_collection, collection_fields] = await Promise.all([
+    extractCollectionClassname(
+      target_locreq.resolve(
+        "src/back/collections/" + collection_name + ".ts"
+      )
+    ),
+    extract_fields_from_collection(collection_name)
+  ]);
+  const importPath = curryImportPath(newfilefullpath);
+  const field_import_string = Array.from(
+    new Set(
+      collection_fields.map((field) => fieldImport(field, importPath))
+    )
+  ).join("\n");
+  const result = `import type { Context } from "koa";
+import type { CollectionItem } from "sealious";
+import type { FlatTemplatable, Templatable } from "tempstream";
+import { TempstreamJSX, tempstream } from "tempstream";
+import { ${uppercase_collection} } from "${importPath(
+    target_locreq.resolve("src/back/collections/collections.ts")
+  )}";
+import html from "${importPath(target_locreq.resolve("src/back/html.ts"))}";
+import type { ListFilterRender } from "@sealcode/sealgen";
+import {
+	SealiousItemListPage,
+	BaseListPageFields,
+	DefaultListFilters,
+} from "@sealcode/sealgen";
+import qs from "qs";
+
+${hooks.post_import_js}
+${field_import_string}
+
+export const actionName = "${action_name}";
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+const filterFields = [
+     ${makeDefaultFilterFields(collection_fields)}
+] as {
+	field: keyof (typeof ${uppercase_collection})["fields"];
+	render?: ListFilterRender;
+	prepareValue?: (filter_value: unknown)=>unknown; // set this function to change what filter value is passed to Sealious
+}[];
+
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+const displayFields = [
+${makeDefaultDisplayFields(collection_fields)}
+] as {
+	field: string;
+	label: string;
+	format?: (value: unknown, item: CollectionItem<typeof ${toPascalCase(
+    collection_name
+  )}>) => FlatTemplatable;
+}[];
+
+export default new (class ${action_name}Page extends SealiousItemListPage<
+	typeof ${uppercase_collection},
+	typeof BaseListPageFields
+> {
+	fields = BaseListPageFields;
+
+	async renderFilters(ctx: Context): Promise<FlatTemplatable> {
+		const query_params = qs.parse(ctx.search.slice(1));
+		query_params.page = "1";
+		const filter_values = await super.getFilterValues(ctx);
+		return <form>
+			{Object.entries(query_params).map(([key, value]) => {
+				if (key == "filter") {
+					return "";
+				}
+                // this is necessary to not lose any query params when the user changes the filter values
+				return <input type="hidden" name={key} value={value}/>;
+			})}
+			{filterFields.map(({ field, render }) => {
+				if (!render) {
+					render = DefaultListFilters.fallback.render;
+				}
+				return (
+					render(filter_values[field] || "", this.collection.fields[field]) ||
+					""
+				);
+			})}
+			<input type="submit" />
+		</form>;
+     }
+
+      async getFilterValues(ctx: Context) {
+        // adding opportunity to adjust the values for a given field filter before it's sent to Sealious
+		const values = await super.getFilterValues(ctx);
+		for (const filterField of filterFields) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+			const key = filterField.field as keyof typeof values;
+			if (key in values) {
+				const prepare_fn = filterField.prepareValue;
+				if (prepare_fn) {
+                                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions,  @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+					values[key] = prepare_fn(values[key]) as any;
+				}
+			}
+		}
+		return values;
+	}
+
+    ${hooks.render_item(collection_name)}
+
+	renderListContainer(ctx: Context, content: Templatable): FlatTemplatable {
+		return (
+			<table class="sealious-list ${toKebabCase(action_name)}-table">
+				{this.renderTableHead(ctx, displayFields)}
+				<tbody>{content}</tbody>
+			</table>
+		);
+	}
+
+	renderTableHead(
+		ctx: Context,
+		fields: { field: string; label?: string }[]
+	): FlatTemplatable {
+		return tempstream/* HTML */ \`<thead>
+			<tr>
+				\${fields.map(({ label, field }) => this.renderHeading(ctx, field, label))}
+				<th>Actions</th>
+			</tr>
+		</thead>\`;
+	}
+
+	async render(ctx: Context) {
+		return html(
+			ctx,
+			"${action_name}",
+			<div class="sealious-list-wrapper ${toKebabCase(action_name)}--wrapper">
+				${hooks.pre_header_html}
+				<h2>${action_name} List</h2>
+				${hooks.post_header_html}
+				{super.render(ctx)}
+			</div>
+		);
+	}
+
+})(${uppercase_collection});
+`;
+  return await formatWithPrettier(result);
+}
+export {
+  collectionListTemplate,
+  makeDefaultDisplayFields,
+  makeDefaultFilterFields
+};
+//# sourceMappingURL=collection-list.js.map

package/lib/templates/shared/confirm-item-delete.js

@@ -0,0 +1,74 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { curryImportPath } from "../../utils/import-path.js";
+import { formatWithPrettier } from "../../utils/prettier.js";
+async function askItemDeleteTemplate(ask_delete_action_name, collection_name, newfilefullpath, list_action_name, delete_action_name) {
+  const importPath = curryImportPath(newfilefullpath);
+  const result = `import type { Context } from "koa";
+import { Page } from "@sealcode/sealgen";
+import type { CollectionItem } from "sealious";
+import { TempstreamJSX } from "tempstream";
+import { ${delete_action_name}URL } from "${importPath(
+    "src/back/routes/urls.js"
+  )}";
+import html from "${importPath("src/back/html.ts")}";
+import { ${toPascalCase(collection_name)} as ${toPascalCase(
+    collection_name
+  )}Collection } from "${importPath("src/back/collections/collections.js")}";
+
+export const actionName = "${ask_delete_action_name}";
+
+export default new (class ${ask_delete_action_name}Page extends Page {
+	canAccess = async (ctx: Context) => {
+        const policy = ${toPascalCase(
+    collection_name
+  )}Collection.getPolicy("edit");
+		const response = await policy.check(ctx.$context);
+		 return { canAccess: response?.allowed || false, message: response?.reason || "" };
+	};
+
+    getItemTitle(_ctx: Context, item: CollectionItem<typeof ${toPascalCase(
+    collection_name
+  )}Collection>){
+      return item.get("name")
+    }
+
+	async render(ctx: Context) {
+		const id = ctx.params.id
+        if(!id){throw new Error("Could not read the id param from the URL")}
+		const { items: [item] }  = 
+			await ctx.$app.collections["${toKebabCase(
+    collection_name
+  )}"].list(ctx.$context).ids([id]).fetch();
+
+		if (!item) {
+			throw new Error("Item with given id not found");
+		}
+		return html(
+			ctx,
+			"Delete?",
+			<div>
+				<div class="confirm-delete-page confirm-delete-page--${toKebabCase(
+    collection_name
+  )}">
+					<span>
+						Are you sure you want to remove: {" "}
+						<b>{this.getItemTitle(ctx, item)}</b>
+					</span>
+					<form action={${delete_action_name}URL(item.id)}>
+						<button type="submit">
+							remove
+						</button>
+						<input type="hidden" name="id" value={item?.id} />
+					</form>
+				</div>
+			</div>
+		);
+	}
+})();
+`;
+  return await formatWithPrettier(result);
+}
+export {
+  askItemDeleteTemplate
+};
+//# sourceMappingURL=confirm-item-delete.js.map

package/lib/templates/shared/handlers/boolean.js

@@ -0,0 +1,14 @@
+const boolean_handler = async (_, { name }, ___, { is_required_expr, fields_var }) => ({
+  field: `${name}: new Fields.Boolean(${is_required_expr})`,
+  controls: `new Controls.Checkbox(${fields_var}.${name}, { label: "${name}" })`,
+  initial_value_edit: {
+    fallback_value: `"false"`,
+    parsed_value: `String(item.get("${name}"))`
+  },
+  main_value_sealious: `!!data.${name}`,
+  fallback_value_sealious: "false"
+});
+export {
+  boolean_handler
+};
+//# sourceMappingURL=boolean.js.map

package/lib/templates/shared/handlers/date.js

@@ -0,0 +1,8 @@
+const date_handler = async (_, { name }, ___, { fields_var }) => ({
+  controls: `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}", type: "date"})`,
+  fallback_value_sealious: `undefined`
+});
+export {
+  date_handler
+};
+//# sourceMappingURL=date.js.map

package/lib/templates/shared/handlers/deep-reverse-single-reference.js

@@ -0,0 +1,209 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import extract_fields_from_collection from "../../../utils/extract-fields-from-collection.js";
+const deep_reverse_single_reference_handler = async (collection_name, {
+  name,
+  target,
+  referencing_collection,
+  intermediary_field_that_points_there,
+  referencing_field
+}, ___, { is_required_expr, fields_var }) => {
+  if (!referencing_collection || !target || !intermediary_field_that_points_there || !referencing_field) {
+    console.warn(
+      "missing referencing_collection, target, intermediary_field_that_points_there, or referencing_field member in extracted field info"
+    );
+    return { field: "" };
+  }
+  const referencing_fields = await extract_fields_from_collection(
+    referencing_collection
+  );
+  if (referencing_fields.length == 2) {
+    const post_create = (get_id) => `{
+			 const item_id = ${get_id};
+			 // First, we remove links refering to current item
+			 const {items: existing_links } = (await ctx.$app.collections["${referencing_collection}"]
+				 .list(ctx.$context)
+				 .filter({"${referencing_field}": item_id})
+				 .fetch()
+			 )
+			  const should_exist_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 to_delete = existing_links.filter(
+				  (link) => !should_exist_ids.includes(link.get("${intermediary_field_that_points_there}"))
+			  );
+			  const to_create_ids = should_exist_ids.filter(
+				  (id) => !existing_links.map(({ id }) => id).includes(id)
+			  );
+			  await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+			  // Then, we iterate over all selected values and insert appropriate missing links
+			  const promises = to_create_ids.map(async (id) => {
+				  await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(
+					  ctx.$context,
+					  {
+						  "${referencing_field}": item_id,
+						  "${intermediary_field_that_points_there}": id,
+					  }
+				  );
+			  });
+			  await Promise.all(promises);
+		 }`;
+    return {
+      field: `${name}: new Fields.CheckboxedListField(${is_required_expr}, async (ctx) => {
+				 const { items } = await ctx.$app.collections["${target}"]
+					 .list(ctx.$context)
+					 .fetch();
+
+				 return items.map((s) => ({
+					 label: s.get("name"),
+					 value: s.id,
+				 }));
+			 })`,
+      controls: `new Controls.CheckboxedListInput(${fields_var}.${name}, {
+				label: "${name}",
+			})`,
+      post_edit: post_create(`await this.getID(ctx)`),
+      post_create: post_create(`created.id`),
+      initial_value_edit: `Object.fromEntries((item.get("${name}") || []).map(id=>[id, "on"]))`,
+      sealious_value: () => ""
+    };
+  } else {
+    const initial_value_function_name = `get${toPascalCase(
+      name
+    )}TableInitialValues`;
+    const post_create = (get_id) => `{
+			const item_id = ${get_id};
+			// First, we remove links refering to current item
+			const { items: to_delete } = await ctx.$app.collections[
+				"${toKebabCase(referencing_collection)}"
+			]
+				.list(ctx.$context)
+				.filter({ "${referencing_field}": item_id })
+				.fetch();
+			await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+
+			// Then, we iterate over all selected values and insert appropriate entries for the subcategories relation
+
+			const promises = data["${name}"]
+				.filter((s) => s.selected == true)
+				.map(async (link_info) => {
+					await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(
+						ctx.$context,
+						{
+							"${referencing_field}": item_id,
+							"${intermediary_field_that_points_there}": String(link_info["${intermediary_field_that_points_there}"]),
+							${referencing_fields.filter(
+      ({ type }) => type !== "single-reference"
+    ).map(
+      (field) => `"${field.name}": link_info["${field.name}"]`
+    ).join(",\n")}
+						}
+					);
+				});
+
+			await Promise.all(promises);
+		}`;
+    const initial_value = `(await ${initial_value_function_name}(ctx,item)) as unknown as FormDataValue`;
+    return {
+      imports: {
+        shared: `import type { CollectionItem } from "sealious"; import type { Context } from "koa";`,
+        edit: `import {${initial_value_function_name}} from "../shared.js"; import type { FormDataValue } from "@sealcode/sealgen";`
+      },
+      field: `
+			  ${name}: new Fields.Table({
+				  selected: new Fields.Boolean(false),
+				  "${referencing_field}": new Fields.SimpleFormField(true),
+				  "${intermediary_field_that_points_there}": new Fields.SimpleFormField(true),
+				  ${referencing_fields.filter(({ type }) => type !== "single-reference").map(
+        (field) => `${field.name}: new Fields.SimpleFormField(true)`
+      ).join(",\n")}
+			  })`,
+      controls: `
+                new Controls.Table(${fields_var}.${name}, {
+                      render_fields: {
+						  selected: (fctx, name, value) => /* HTML */ \`<input
+							  type="checkbox"
+							  name=\${name}
+							  \${value?.toString() == "true" ? "checked" : ""}
+							  form="\${fctx.form_id}"
+							  autocomplete="off"
+						  />\`,
+						  "${referencing_field}": (fctx, name, value) => /* HTML */ \`<input
+							  type="hidden"
+							  name=\${name}
+							  value="\${value}"
+							  form="\${fctx.form_id}"
+						  />\`,
+						  "${intermediary_field_that_points_there}": (fctx, name, value) => /* HTML */ \`<input
+							  type="hidden"
+							  name=\${name}
+							  value="\${value}"
+							  form="\${fctx.form_id}"
+						  />\`,
+						 ${referencing_fields.filter(
+        ({ type }) => type !== "single-reference"
+      ).map(
+        (field) => `${field.name}: (fctx, name, value) => /* HTML */ \`<input
+										  name=\${name}
+										  value="\${value}"
+										  form="\${fctx.form_id}"
+										  autocomplete="off"
+									  />\``
+      ).join(",\n")}
+                      },
+                      allow_adding: false,
+				  })`,
+      top_level_shared: `export async function ${initial_value_function_name}(
+					ctx: Context,
+                    item: CollectionItem<typeof ${toPascalCase(
+        collection_name
+      )}>
+				) {
+                    // convert from an array to array-like object
+					return Object.fromEntries(
+						await Promise.all([
+							ctx.$app.collections["${toKebabCase(target)}"].list(ctx.$context).fetch(),
+							ctx.$app.collections["${toKebabCase(
+        referencing_collection
+      )}"].list(ctx.$context).fetch(),
+						]).then(([{ items: targets }, { items: links }]) =>
+							targets
+								.map((target) => {
+									return {
+										selected: (item.get("${name}") || []).includes(
+											target.id
+										)
+											? "on"
+											: "off",
+										"${referencing_field}": item.id,
+										"${intermediary_field_that_points_there}": target.id,
+                                        ${referencing_fields.filter(
+        ({ type }) => type !== "single-reference"
+      ).map(
+        (field) => `"${field.name}": links
+												.find(
+													(e) =>
+														e.get("${intermediary_field_that_points_there}") == target.id &&
+														e.get("${referencing_field}") == item.id
+												)
+												?.get("rank") || 0,`
+      ).join(",\n")}
+									};
+								})
+								.entries()
+						)
+					);
+				}`,
+      initial_value_edit: initial_value,
+      initial_value_create: initial_value,
+      post_edit: post_create(`await this.getID(ctx)`),
+      post_create: post_create(`created.id`)
+    };
+  }
+};
+export {
+  deep_reverse_single_reference_handler
+};
+//# sourceMappingURL=deep-reverse-single-reference.js.map