@sealcode/sealgen 0.15.33 → 0.15.35

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

@@ -0,0 +1,200 @@
+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";
+import { renderFieldForSealious } from "./collection-create-form.js";
+function renderFieldForInitialValues({
+  name,
+  type,
+  is_required,
+  is_readonly
+}) {
+  if (type == "deep-reverse-single-reference") {
+    return `${name}: Object.fromEntries((item.get("${name}") || []).map(id=>[id, "on"]))`;
+  }
+  if (type == "jdd" || is_readonly) {
+    return "";
+  }
+  if (type == "image" || type == "file") {
+    return `${name}: {old: item.get("${name}")}`;
+  }
+  let fallback_value = `""`;
+  let main_value = `item.get("${name}")`;
+  if (type == "boolean") {
+    fallback_value = `"false"`;
+    main_value = `String(item.get("${name}"))`;
+  }
+  if (is_required) {
+    return `${name}: ${main_value}`;
+  } else {
+    return `${name}: ${main_value} || ${fallback_value}`;
+  }
+}
+function renderFieldPreEditAction({ 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 renderFieldPostEditAction({
+  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 `{
+            const item_id = await this.getID(ctx);
+	    	// First, we remove links refering to current item
+            const {items:to_delete} = (await ctx.$app.collections["${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 ${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}": item_id,
+						"${intermediary_field_that_points_there}": id,
+					}
+				);
+			});
+
+			await Promise.all(promises);
+        }`;
+  }
+  return "";
+}
+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);
+  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, ${toPascalCase(
+      edit_action_name
+    )}URL } from "${importPath("src/back/routes/urls.js")}";
+
+        import {tempstream} from "tempstream";
+`,
+    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");
+				}
+
+			   ${collection_fields.map((field) => renderFieldPreEditAction(field)).filter((e) => e !== "").join("\n")}
+
+				item.setMultiple(
+					{
+						${collection_fields.map((field) => renderFieldForSealious(field)).filter((e) => e != "").join(",\n")}
+					}
+				);
+                await item.save(ctx.$context);
+
+                
+                 // ## POST-EDIT ACTIONS ############
+                 ${collection_fields.map((field) => renderFieldPostEditAction(field)).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 = 
+                         ${toPascalCase(edit_action_name)}URL.params
+                         .find(param => param.toLowerCase().includes("id")) 
+                     || ${toPascalCase(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 {
+				   ${collection_fields.map((field) => renderFieldForInitialValues(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 {
+  editItemFormTemplate
+};
+//# sourceMappingURL=collection-edit-form.js.map

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

@@ -0,0 +1,211 @@
+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 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 result = `import type { Context } from "koa";
+import type { CollectionItem, ItemListResult } 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";
+import type { FilePointer } from "@sealcode/file-manager";
+import { imageRouter } from "${importPath(
+    target_locreq.resolve("src/back/image-router.ts")
+  )}";
+
+${hooks.post_import_js}
+
+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
+}[];
+
+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) {
+			const key = filterField.field as keyof typeof values;
+			if (key in values) {
+				const prepare_fn = filterField.prepareValue;
+				if (prepare_fn) {
+					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,72 @@
+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)} } 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)}.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
+  )}>){
+      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/item-delete.js

@@ -0,0 +1,41 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { curryImportPath } from "../../utils/import-path.js";
+function itemDeleteTemplate(delete_action_name, collection_name, newfilefullpath, list_action_name) {
+  const importPath = curryImportPath(newfilefullpath);
+  return `import { Context } from "koa";
+import { Mountable } from "@sealcode/sealgen";
+import Router from "@koa/router";
+
+import { ${toPascalCase(collection_name)} } from "${importPath(
+    "src/back/collections/collections.js"
+  )}";
+
+import { ${list_action_name}URL } from "${importPath(
+    "src/back/routes/urls.js"
+  )}";
+
+export const actionName = "${delete_action_name}";
+
+export default new (class ${delete_action_name}Redirect extends Mountable {
+    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 || "" };
+	};
+
+	mount(router: Router, path: string) {
+		router.get(path, async (ctx) => {
+            ctx.$app.collections["${toKebabCase(
+    collection_name
+  )}"].removeByID(ctx.$context, ctx.params.id);
+			ctx.status = 302;
+			ctx.redirect(${list_action_name}URL);
+		});
+	}
+})();
+`;
+}
+export {
+  itemDeleteTemplate
+};
+//# sourceMappingURL=item-delete.js.map

package/lib/templates/shared/shared-crud-form-fields.js

@@ -0,0 +1,118 @@
+import { toPascalCase } from "js-convert-case";
+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 { formatWithPrettier } from "../../utils/prettier.js";
+const target_locreq = _locreq(process.cwd());
+function renderFieldImports(field) {
+  if (field.type == "enum") {
+    return `import type { FieldTypes } from "sealious";`;
+  }
+}
+function renderFormField(collection_name, { name, type, target, is_readonly }) {
+  const required_s = `${toPascalCase(
+    collection_name
+  )}.fields.${name}.required`;
+  if (type == "image" || type == "file") {
+    return `${name}: new Fields.File(${required_s}, TheFileManager)`;
+  }
+  if (type == "int") {
+    return `${name}: new Fields.NumberField(${required_s}, 0)`;
+  }
+  if (type == "boolean") {
+    return `${name}: new Fields.Boolean(${required_s})`;
+  }
+  if (type == "enum") {
+    return `${name}: new Fields.PickFromListField(
+			${toPascalCase(collection_name)}.fields["${name}"].required,
+			async (ctx) =>
+				// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+				(${toPascalCase(collection_name)}.fields["${name}"] as FieldTypes.Enum<string>)
+					.getAllowedValues(ctx.$app)
+					.map((value) => ({ value, label: value }))
+		)`;
+  }
+  if (is_readonly || type == "jdd") {
+    return "";
+  }
+  if (type == "deep-reverse-single-reference" && target) {
+    return `${name}: new Fields.CheckboxedListField(${required_s}, async (ctx) => {
+			const { items } = await ctx.$app.collections["${target}"]
+				.list(ctx.$context)
+				.fetch();
+
+			return items.map((s) => ({
+				label: s.get("name"),
+				value: s.id,
+			}));
+		})`;
+  }
+  return `${name}: new Fields.CollectionField(${required_s}, ${toPascalCase(
+    collection_name
+  )}.fields.${name})`;
+}
+function renderFormControl(collection_name, { name, type, target, is_readonly }) {
+  const fields_var = `${toPascalCase(collection_name)}FormFields`;
+  if (is_readonly || type == "jdd") {
+    return "";
+  }
+  if (type == "int") {
+    return `new Controls.Number(${fields_var}.${name}, { label: "${name}" })`;
+  }
+  if (type == "deep-reverse-single-reference" && target) {
+    return `new Controls.CheckboxedListInput(${fields_var}.${name}, {
+			 label: "${name}",
+		 })`;
+  }
+  if (type == "boolean") {
+    return `new Controls.Checkbox(${fields_var}.${name}, { label: "${name}" })`;
+  }
+  if (type == "date") {
+    return `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}", type: "date"})`;
+  }
+  if (type == "enum") {
+    return `new Controls.Dropdown(${fields_var}.${name}, { label: "${name}"})`;
+  }
+  if (type == "image") {
+    return `new Controls.Photo(${fields_var}.${name}, imageRouter, {
+			label: "${name}",
+		})`;
+  }
+  return `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}"})`;
+}
+async function sharedCrudFormFields(collection_name, newfilefullpath) {
+  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 result = `import { Controls, Fields } from "@sealcode/sealgen";
+import { ${uppercase_collection} } from "${importPath(
+    "src/back/collections/collections.js"
+  )}";
+import { TheFileManager } from "${importPath("src/back/file-manager.js")}";
+import { imageRouter } from "${importPath("src/back/image-router.js")}";
+
+${Array.from(
+    new Set(collection_fields.map((field) => renderFieldImports(field)))
+  ).join(";\n")}
+
+export const ${toPascalCase(collection_name)}FormFields = <const>{
+	${collection_fields.map((field) => renderFormField(collection_name, field)).filter((e) => e != "").join(",\n")}
+};
+
+export const ${toPascalCase(collection_name)}FormControls = [
+	${collection_fields.map((field) => renderFormControl(collection_name, field)).filter((e) => e != "").join(",\n")}
+];
+`;
+  return formatWithPrettier(result);
+}
+export {
+  sharedCrudFormFields
+};
+//# sourceMappingURL=shared-crud-form-fields.js.map

package/lib/utils/utils.js

@@ -13,6 +13,7 @@ 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";
 export {
   UrlWithNewParams,
   assertThrowsAsync,

package/lib/utils/with-fallback.js

@@ -0,0 +1,21 @@
+function withFallback(value1, value2, value3) {
+  if (value3 !== void 0) {
+    if (value1 !== null && value1 !== void 0 && value2 !== null && value2 !== void 0) {
+      return value2;
+    } else {
+      return value3;
+    }
+  } else {
+    if (value1 !== null && value1 !== void 0) {
+      return value1;
+    } else if (value2 !== void 0 && value2 !== null) {
+      return value2;
+    } else {
+      throw new Error("No suitable fallback: ${arguments}");
+    }
+  }
+}
+export {
+  withFallback
+};
+//# sourceMappingURL=with-fallback.js.map

package/lib/utils/write-file.js

@@ -0,0 +1,11 @@
+import { promises as fs } from "node:fs";
+import { resolve } from "path";
+async function writeFile(path, content) {
+  await fs.mkdir(resolve(path, "../"), { recursive: true });
+  await fs.writeFile(path, content);
+  console.log(`${path} created`);
+}
+export {
+  writeFile
+};
+//# sourceMappingURL=write-file.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sealcode/sealgen",
-	"version": "0.15.33",
+	"version": "0.15.35",
 	"description": "Module to automate adding routes and collections to a sealious application",
 	"main": "lib/index.js",
 	"type": "module",