@sealcode/sealgen 0.11.8 → 0.12.0

package/dist/page/mountable-with-fields.js

@@ -0,0 +1,106 @@
+import { tempstream } from "tempstream";
+import {
+  FormControlContext
+} from "../forms/controls/form-control.js";
+import { Mountable } from "./mountable.js";
+class MountableWithFields extends Mountable {
+  constructor() {
+    super();
+    this.field_names_prefix = "";
+    // useful for multiform, where many forms are merged into one and field assignment is made using the prefix
+    this.form_id = "";
+    if (!this.fields)
+      this.fields = {};
+  }
+  init() {
+    for (const [name, field] of Object.entries(this.fields)) {
+      field.init(name);
+    }
+  }
+  makeFormControlContext(ctx, data, validate, field_name_prefix = this.field_names_prefix, form_id = this.form_id) {
+    return new FormControlContext(
+      ctx,
+      data.raw_values,
+      data.messages,
+      field_name_prefix,
+      form_id,
+      validate
+    );
+  }
+  // this one is meant to be overwritten
+  async validateValues(ctx, data) {
+    return {
+      valid: true,
+      error: ""
+    };
+  }
+  async validate(ctx, values) {
+    const field_errors = {};
+    let valid = true;
+    const form_messages = [];
+    await Promise.all(
+      Object.entries(values).filter(([fieldname]) => fieldname in this.fields).map(async ([key]) => {
+        const field = this.fields[key];
+        const { valid: fieldvalid, message: fieldmessage } = await field.getValue(ctx, values);
+        if (!fieldvalid) {
+          valid = false;
+          field_errors[field.name] = fieldmessage;
+        }
+      })
+    );
+    const formValidationResult = await this.validateValues(ctx, values);
+    if (!formValidationResult.valid) {
+      form_messages.push({
+        type: "error",
+        text: formValidationResult.error
+      });
+      valid = false;
+    }
+    return { valid, field_errors, form_messages };
+  }
+  renderControls(fctx) {
+    return tempstream`${this.controls.map(
+      (control) => control.render(fctx)
+    )}`;
+  }
+  async renderError(_, error) {
+    return error.message;
+  }
+  renderMessages(_, data) {
+    return tempstream`<div class="form-messages">
+			${data.messages.map(
+      (message) => `<div class="form-message form-message--${message.type}">${message.text}</div>`
+    )}
+		</div>`;
+  }
+  async getParsedValues(ctx) {
+    const raw_values = await this.extractRawValues(ctx);
+    const result = {};
+    const promises = Object.entries(this.fields).map(
+      async ([key, field]) => {
+        const { parsed } = await field.getValue(ctx, raw_values);
+        result[key] = parsed;
+      }
+    );
+    await Promise.all(promises);
+    return result;
+  }
+  async getDatabaseValues(ctx) {
+    const raw_values = await this.extractRawValues(ctx);
+    const result = {};
+    const promises = Object.entries(this.fields).map(
+      async ([key, field]) => {
+        const db_value = await field.getDatabaseValue(ctx, raw_values);
+        if (db_value !== void 0) {
+          result[key] = db_value;
+        }
+      }
+    );
+    await Promise.all(promises);
+    return result;
+  }
+}
+export {
+  MountableWithFields
+};
+//# sourceMappingURL=mountable-with-fields.js.map

package/dist/page/mountable.js

@@ -0,0 +1,9 @@
+class Mountable {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  init() {
+  }
+}
+export {
+  Mountable
+};
+//# sourceMappingURL=mountable.js.map

package/dist/page/page.js

@@ -0,0 +1,31 @@
+import { tempstream } from "tempstream";
+import {
+  MountableWithFields
+} from "./mountable-with-fields.js";
+import { AllQueryParams } from "./props-parser.js";
+class Page extends MountableWithFields {
+  constructor() {
+    super(...arguments);
+    this.propsParser = new AllQueryParams();
+    this.controls = [];
+  }
+  mount(router, path) {
+    router.get(path, async (ctx) => {
+      ctx.body = await this.render(ctx);
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async canAccess(_) {
+    return { canAccess: true, message: "" };
+  }
+  async renderError(_, error) {
+    return tempstream`<div>${error.message}</div>`;
+  }
+  async extractRawValues(ctx) {
+    return this.propsParser.decode(ctx) || {};
+  }
+}
+export {
+  Page
+};
+//# sourceMappingURL=page.js.map

package/dist/page/props-parser.js

@@ -0,0 +1,24 @@
+import merge from "merge";
+class PagePropsParser {
+  overwriteProp(ctx, new_props) {
+    const result = {};
+    merge.recursive(result, this.decode(ctx), new_props);
+    return result;
+  }
+}
+class AllQueryParams extends PagePropsParser {
+  decode(ctx) {
+    return ctx.query;
+  }
+  encode(props) {
+    return props;
+  }
+  getHTMLInputName(prop_name) {
+    return prop_name;
+  }
+}
+export {
+  AllQueryParams,
+  PagePropsParser
+};
+//# sourceMappingURL=props-parser.js.map

package/dist/page/sealious-list.js

@@ -0,0 +1,61 @@
+import { ListPage } from "./list.js";
+import { peopleWhoCan } from "./access-control.js";
+import qs from "qs";
+import { is, predicates } from "@sealcode/ts-predicates";
+class SealiousItemListPage extends ListPage {
+  constructor(collection) {
+    super();
+    this.collection = collection;
+    this.canAccess = peopleWhoCan("list", this.collection);
+  }
+  async getContextForList(ctx) {
+    return ctx.$context;
+  }
+  async getTotalPages(ctx, itemsPerPage) {
+    const query = this.collection.list(await this.getContextForList(ctx));
+    await this.addFilter(ctx, query);
+    const { items } = await query.fetch();
+    return Math.ceil(items.length / itemsPerPage);
+  }
+  async addFilter(ctx, list) {
+    const filters = await this.getFilterValues(ctx);
+    for (const key in filters) {
+      if (filters[key] === void 0 || filters[key] == "") {
+        delete filters[key];
+      }
+    }
+    if (Object.keys(filters).length) {
+      list.filter(filters);
+    }
+  }
+  async makeQuery(ctx) {
+    const query = this.collection.list(await this.getContextForList(ctx));
+    const sort = await this.getSort(ctx);
+    if (sort) {
+      query.sort({ [sort.field]: sort.order });
+    }
+    return query;
+  }
+  async getItems(ctx, page, itemsPerPage) {
+    const query = await this.makeQuery(ctx);
+    await this.addFilter(ctx, query);
+    const { items } = await query.paginate({ items: itemsPerPage, page }).fetch();
+    return items;
+  }
+  async getFilterValues(ctx) {
+    const query_params = qs.parse(ctx.search.slice(1));
+    const _filter_values = query_params?.filter || {};
+    let filter_values = is(
+      _filter_values,
+      predicates.record(predicates.string, predicates.string)
+    ) ? _filter_values : {};
+    return filter_values;
+  }
+  async renderItem(_, item, index) {
+    return `<div>${item.id}</div>`;
+  }
+}
+export {
+  SealiousItemListPage
+};
+//# sourceMappingURL=sealious-list.js.map

package/dist/page/stateful-page.js

@@ -0,0 +1,123 @@
+import { predicates, hasShape, is } from "@sealcode/ts-predicates";
+import deepmerge from "deepmerge";
+import { tempstream } from "tempstream";
+import { from_base64, to_base64 } from "../utils/base64.js";
+import { Mountable } from "./mountable.js";
+class StatefulPage extends Mountable {
+  async canAccess() {
+    return { canAccess: true, message: "" };
+  }
+  constructor() {
+    super();
+    const original_render = this.render.bind(this);
+    this.render = async (ctx, state, inputs) => {
+      return this.wrapInLayout(
+        ctx,
+        this.wrapInForm(
+          state,
+          await original_render(ctx, state, inputs)
+        )
+      );
+    };
+  }
+  wrapInForm(state, content) {
+    return tempstream`<form action="./" method="POST">
+			<input
+				name="state"
+				type="hidden"
+				value="${to_base64(JSON.stringify(state))}"
+			/>
+			${content}
+		</form>`;
+  }
+  makeActionButton(state, action_description, ...args) {
+    let label, action;
+    if (is(action_description, predicates.object)) {
+      action = action_description.action.toString();
+      label = action_description.label || action;
+    } else {
+      action = action_description.toString();
+      label = action;
+    }
+    return (
+      /* HTML */
+      `
+			<input
+				type="submit"
+				value=${label}
+				formaction="./?action=${action}&args=${to_base64(
+        JSON.stringify(args)
+      )}"
+			/>
+		`
+    );
+  }
+  extractState(ctx) {
+    if (!hasShape(
+      {
+        action: predicates.maybe(predicates.string),
+        state: predicates.string,
+        args: predicates.maybe(predicates.string),
+        $: predicates.maybe(predicates.object)
+      },
+      ctx.$body
+    )) {
+      console.error("Wrong data: ", ctx.$body);
+      throw new Error("wrong formdata shape");
+    }
+    const inputs = Object.fromEntries(
+      Object.entries(ctx.$body).filter(
+        ([key]) => !["action", "state", "args", "$"].includes(key)
+      )
+    );
+    const original_state = JSON.parse(from_base64(ctx.$body.state));
+    const modified_state = deepmerge(original_state, ctx.$body.$ || {}, {
+      arrayMerge: (_target, source, _options) => {
+        return source;
+      }
+    });
+    if (ctx.$body.action && ctx.$body.args) {
+      return {
+        state: modified_state,
+        action: ctx.$body.action,
+        inputs,
+        action_args: ctx.$body.args
+      };
+    } else {
+      return {
+        state: modified_state,
+        action: null,
+        action_args: null,
+        inputs
+      };
+    }
+  }
+  mount(router, path) {
+    router.get(path, (ctx) => {
+      ctx.body = this.render(ctx, this.getInitialState(), {});
+    });
+    router.post(path, (ctx) => {
+      const { action, state, inputs, action_args } = this.extractState(ctx);
+      if (action) {
+        ctx.body = this.render(
+          ctx,
+          this.actions[action](
+            state,
+            inputs,
+            ...JSON.parse(
+              from_base64(action_args)
+            )
+          ),
+          inputs
+        );
+      } else {
+        ctx.body = this.render(ctx, state, inputs);
+      }
+      ctx.status = 433;
+    });
+  }
+}
+export {
+  StatefulPage
+};
+//# sourceMappingURL=stateful-page.js.map

package/dist/run.js

@@ -0,0 +1 @@
+//# sourceMappingURL=run.js.map

package/dist/sample-index.js

@@ -0,0 +1,3 @@
+import { hehe } from "./sample-lib.js";
+hehe.hehe();
+//# sourceMappingURL=sample-index.js.map

package/dist/sample-lib.js

@@ -0,0 +1,9 @@
+class hehe {
+  static hehe() {
+    console.log("hehe");
+  }
+}
+export {
+  hehe
+};
+//# sourceMappingURL=sample-lib.js.map

package/dist/sanitize.js

@@ -0,0 +1,10 @@
+function attribute(raw) {
+  if (typeof raw !== "string") {
+    raw = raw.toString();
+  }
+  return (raw || "").replaceAll("<", "&lt;").replace('"', "&quot;").replaceAll("'", "&#39;");
+}
+export {
+  attribute
+};
+//# sourceMappingURL=sanitize.js.map

package/dist/templates/collection.js

@@ -0,0 +1,15 @@
+function collectionTemplate(collection_name) {
+  return `import { Collection, FieldTypes, Policies } from "sealious";
+
+export default class ${collection_name} extends Collection {
+	fields = {
+		content: new FieldTypes.Text(),
+	};
+	defaultPolicy = new Policies.Public();
+}
+`;
+}
+export {
+  collectionTemplate
+};
+//# sourceMappingURL=collection.js.map

package/dist/templates/form.js

@@ -0,0 +1,60 @@
+import { curryImportPath } from "../utils/import-path.js";
+async function formTemplate(action_name, newfilefullpath) {
+  const rel = curryImportPath(newfilefullpath);
+  return `import { Context } from "koa";
+import { Form, FormData, FormDataValue, Fields, Controls } from "@sealcode/sealgen";
+import html from "${rel("src/back/html.js")}";
+import { Users } from "${rel("src/back/collections/collections.js")}";
+
+export const actionName = "${action_name}";
+
+const fields = {
+	email: new Fields.CollectionField(true, Users.fields.email),
+	password: new Fields.SimpleFormField(true),
+};
+
+export const ${action_name}Shape = Fields.fieldsToShape(fields);
+
+export default new (class ${action_name}Form extends Form<typeof fields, void> {
+	defaultSuccessMessage = "Formularz wype\u0142niony poprawnie";
+	fields = fields;
+
+	controls = [
+		new Controls.SimpleInput(fields.email, { label: "Email:", type: "email" }),
+		new Controls.SimpleInput(fields.password, { label: "Password:", type: "password" }),
+	];
+
+	async validateValues(
+		ctx: Context,
+		data: Record<string, FormDataValue>
+	): Promise<{ valid: boolean; error: string }> {
+		// just an example
+		const { parsed: email } = await this.fields.email.getValue(ctx, data);
+		const { parsed: password } = await this.fields.password.getValue(ctx, data);
+		if ((password || "").length > (email || "").length) {
+			return { valid: false, error: "Password cannot be longer than email" };
+		} else {
+			return { valid: true, error: "" };
+		}
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: Context) {
+		return { canAccess: true, message: "" };
+	}
+
+	async onSubmit() {
+		//noop
+		return;
+	}
+
+	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
+		return html(ctx, "${action_name}", await super.render(ctx, data, show_field_errors));
+	}
+})();
+`;
+}
+export {
+  formTemplate
+};
+//# sourceMappingURL=form.js.map

package/dist/templates/jdd-component.js

@@ -0,0 +1,44 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+function jddComponentTemplate(component_name) {
+  return `import { FlatTemplatable, TempstreamJSX } from "tempstream";
+import {
+	Component,
+	ComponentArguments,
+	ExtractStructuredComponentArgumentsValues,
+	JDDContext,
+} from "@sealcode/jdd";
+
+const component_arguments = {
+	title: new ComponentArguments.ShortText(),
+	content: new ComponentArguments.Markdown(),
+} as const;
+
+export class ${toPascalCase(
+    component_name
+  )} extends Component<typeof component_arguments> {
+	getArguments() {
+		return component_arguments;
+	}
+
+	toHTML(
+		{
+			title,
+			content,
+		}: ExtractStructuredComponentArgumentsValues<typeof component_arguments>,
+		{ render_markdown }: JDDContext
+	): FlatTemplatable {
+		return (
+			<div class="${toKebabCase(component_name)}">
+				<h2>{title} \u2022 ${toPascalCase(component_name)} </h2>
+				<div>{render_markdown(content)}</div>
+			</div>
+		);
+	}
+}
+
+`;
+}
+export {
+  jddComponentTemplate
+};
+//# sourceMappingURL=jdd-component.js.map

package/dist/templates/list.js

@@ -0,0 +1,144 @@
+import _locreq from "locreq";
+import { curryImportPath } from "../utils/import-path.js";
+import prompts from "prompts";
+import { listCollections } from "../utils/list-collections.js";
+import { extractCollectionClassname } from "../generate-collections.js";
+import extract_fields_from_collection from "../utils/extract-fields-from-collection.js";
+import { DefaultListFilters } from "../page/default-list-filters.js";
+const target_locreq = _locreq(process.cwd());
+const listTemplate = async (action_name, newfilefullpath) => {
+  const response = await prompts({
+    type: "autocomplete",
+    name: "collection",
+    message: "Which sealious collection do you want to list?",
+    choices: (await listCollections()).map((collection) => ({
+      title: collection,
+      value: collection
+    }))
+  });
+  const collection_name = response.collection;
+  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 rel = curryImportPath(newfilefullpath);
+  return `import { Context } from "koa";
+import { CollectionItem } from "sealious";
+import { FlatTemplatable, TempstreamJSX } from "tempstream";
+import { ${uppercase_collection} } from "${rel(
+    "src/back/collections/collections.js"
+  )}";
+import html from "${rel("src/back/html.js")}";
+import {
+	SealiousItemListPage,
+	BaseListPageFields,
+	DefaultListFilters,
+    ListFilterRender,
+} from "@sealcode/sealgen";;
+import qs from "qs";
+import { is, predicates } from "@sealcode/ts-predicates";
+
+export const actionName = "${action_name}";
+
+const filterFields = [
+${collection_fields.map(
+    (field) => `	{ field: "${field.name}", render: ${DefaultListFilters[field.type] ? `DefaultListFilters["${field.type}"]` : `DefaultListFilters.fallback`} }`
+  ).join(",\n")}
+] as {
+	field: keyof (typeof ${uppercase_collection})["fields"];
+	render?: ListFilterRender;
+}[];
+
+const displayFields = [
+${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(" ");
+		},
+	}`;
+    }
+    return `	{ field: "${field.name}", label: "${field.name}" }`;
+  }).join(",\n")}
+];
+
+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 this.getFilterValues(ctx);
+		return <form>
+			{Object.entries(query_params).map(([key, value]) => {
+				if (key == "filter") {
+					return "";
+				}
+				return <input
+					type="hidden"
+					name="\${key}"
+					value="\${value}"
+				/>;
+			})}
+			{filterFields.map(({ field, render }) => {
+				if (!render) {
+					render = DefaultListFilters.fallback;
+				}
+
+				return (
+					render(filter_values[field] || "", this.collection.fields[field]) ||
+					""
+				);
+			})}
+			<input type="submit" />
+		</form>;
+	}
+
+	async renderItem(_: Context, item: CollectionItem<typeof ${uppercase_collection}>) {
+		return <tr>
+			{displayFields.map(({ field, format }) => {
+				const value = item.get(field as any);
+				return <td>{format ? format(value) : value}</td>;
+			})}
+		</tr>;
+	}
+
+	async render(ctx: Context) {
+		return html(
+			ctx,
+			"${action_name}",
+			<div>
+				<h2>${action_name} List</h2>
+				<table class="sealious-list">
+					{this.renderTableHead(ctx, displayFields)}
+					<tbody>{super.render(ctx)}</tbody>
+				</table>
+			</div>
+		);
+	}
+
+})(${uppercase_collection});
+`;
+};
+export {
+  listTemplate
+};
+//# sourceMappingURL=list.js.map