@sealcode/sealgen 0.3.1 → 0.4.1

package/src/templates/list.ts

@@ -27,38 +27,48 @@ import { tempstream } from "tempstream";
 import { ${uppercase_collection} } from "${rel(
 		"src/back/collections/collections"
 	)}";
-import html from "${rel("src/back/html.ts")}";
-import {
-	BaseListPageDefaultProps,
-	BaseListPageProps,
-	BaseListPagePropsShape,
-	SealiousItemListPage,
-} from "${rel("src/back/page/list.ts")}";
-import { AllQueryParams } from "${rel("src/back/page/props-parser.ts")}";
+import html from "../../html";
+import { SealiousItemListPage, BaseListPageFields } from "@sealcode/sealgen";
 
 export const actionName = "${action_name}";
 
-export default new (class ${action_name}Page extends SealiousItemListPage<typeof ${uppercase_collection}> {
-	propsParser = new AllQueryParams<BaseListPageProps>(
-		BaseListPagePropsShape,
-		BaseListPageDefaultProps
-	);
+const filterFields = {};
+
+export default new (class ${action_name}Page extends SealiousItemListPage<
+	typeof ${uppercase_collection},
+	typeof BaseListPageFields
+> {
+	fields = BaseListPageFields;
+
+	filterFields = filterFields;
+	filterControls = [];
 
 	async render(ctx: BaseContext) {
 		return html(
 			ctx,
-            "${uppercase_collection}",
+			"${uppercase_collection}",
 			tempstream/* HTML */ \`<div>
-                <h2>${uppercase_collection} List</h2>
-				<ul>
-					\${super.render(ctx)}
-				</ul>
+				<h2>${uppercase_collection} List</h2>
+				<table>
+					<thead>
+						<th>id</th>
+						\${Object.keys(${uppercase_collection}.fields).map(
+							(fieldname) => \`<th>\${fieldname}</th>\`
+						)}
+					</thead>
+					<tbody>
+						\${super.render(ctx)}
+					</tbody>
+				</table>
 			</div>\`
 		);
 	}
 
-    async renderItem(_: BaseContext, item: CollectionItem<typeof ${uppercase_collection}>) {
-		return tempstream\`<li>\${item.id}</li>\`;
+	async renderItem(_: BaseContext, item: CollectionItem<typeof ${uppercase_collection}>) {
+		return tempstream\`<tr><td>\${item.id}</td>\${Object.keys(${uppercase_collection}.fields).map(
+			(fieldname: keyof typeof ${uppercase_collection}["fields"]) =>
+				tempstream\`<td>\${item.get(fieldname)}</td>\`
+		)}</tr>\`;
 	}
 })(${uppercase_collection});
 `;

package/src/templates/page.ts

@@ -1,24 +1,24 @@
-import { importPath } from "../utils/import-path";
-
+import { curryImportPath } from "../utils/import-path";
 export async function pageTemplate(
 	action_name: string,
-	fullpath: string
+	newfilefullpath: string
 ): Promise<string> {
+	const rel = curryImportPath(newfilefullpath);
 	return `import { BaseContext } from "koa";
 import { tempstream } from "tempstream";
-import { Page } from "${importPath(fullpath, "src/back/page/page")}";
+import { Page } from "@sealcode/sealgen";
+import html from "${rel("src/back/html")}";
 
 export const actionName = "${action_name}";
 
 export default new (class ${action_name}Page extends Page {
-
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	async canAccess(_: BaseContext) {
 		return { canAccess: true, message: "" };
 	}
 
 	async render(ctx: BaseContext) {
-		return tempstream/* HTML */ \`<div></div>\`;
+		return html(ctx, "${action_name}", tempstream/* HTML */ \`<div></div>\`);
 	}
 })();
 `;

package/src/utils/escape-url-params.ts

@@ -2,6 +2,7 @@ export function escape_url_params(url: string): string {
 	return url
 		.split("/")
 		.map((e) => (e.startsWith(":") ? `[${e.slice(1)}]` : e))
+		.filter((e) => e != "")
 		.join("/");
 }
 

package/src/forms/field.ts

@@ -1,119 +0,0 @@
-import { is, predicates } from "@sealcode/ts-predicates";
-import { BaseContext } from "koa";
-
-export type FormFieldValidationResponse = { valid: boolean; message: string };
-
-export type FormFieldValidationFn = (
-	ctx: BaseContext,
-	value: unknown,
-	field: FormField
-) => Promise<FormFieldValidationResponse>;
-
-export class FormField<Fieldnames extends string = string> {
-	constructor(
-		public name: Fieldnames,
-		public required: boolean = false,
-		public validator: FormFieldValidationFn = async () => ({
-			valid: true,
-			message: "",
-		})
-	) {}
-
-	public async _validate(
-		ctx: BaseContext,
-		value: unknown
-	): Promise<FormFieldValidationResponse> {
-		if (this.required && (value == "" || value == null || value == undefined)) {
-			return { valid: false, message: "This field is required" };
-		}
-		return this.validator(ctx, value, this);
-	}
-
-	public getEmptyValue() {
-		return "";
-	}
-}
-
-export class PickFromListField<
-	Fieldnames extends string = string
-> extends FormField<Fieldnames> {
-	constructor(
-		public name: Fieldnames,
-		public required: boolean = false,
-		public generateOptions: (
-			ctx: BaseContext
-		) => Promise<Record<string, string> | { [i: string]: string }>,
-		public customValidation: (
-			ctx: BaseContext,
-			value: unknown,
-			instance: PickFromListField
-		) => Promise<FormFieldValidationResponse> = (ctx, value, instance) =>
-			instance.valueInList(ctx, value)
-	) {
-		super(name, required, (ctx, value) => this.customValidation(ctx, value, this));
-	}
-
-	async valueInList(
-		ctx: BaseContext,
-		value: unknown
-	): Promise<FormFieldValidationResponse> {
-		const options = await this.generateOptions(ctx);
-		if (!is(value, predicates.string)) {
-			return { valid: false, message: "not a string" };
-		}
-		if (!Object.keys(options).includes(value)) {
-			return { valid: false, message: `"${value}" is not one of the options` };
-		}
-		return { valid: true, message: "" };
-	}
-}
-
-export class ChekboxedListField<
-	Fieldnames extends string = string
-> extends FormField<Fieldnames> {
-	constructor(
-		public name: Fieldnames,
-		public required: boolean = false,
-		public generateOptions: (
-			ctx: BaseContext
-		) => Promise<Record<string, string> | { [i: string]: string }>,
-		public isVisible: (ctx: BaseContext) => Promise<boolean> = () =>
-			Promise.resolve(true)
-	) {
-		super(name, required, (ctx, value) => this.isValueValid(ctx, value));
-	}
-
-	private async isValueValid(
-		_: BaseContext,
-		value: unknown
-	): Promise<FormFieldValidationResponse> {
-		if (is(value, predicates.string)) {
-			return { valid: false, message: "you need an array" };
-		}
-		if (is(value, predicates.null)) {
-			return { valid: false, message: "you need an array" };
-		}
-		return { valid: true, message: "" };
-	}
-}
-
-export class NumberField<
-	Fieldnames extends string = string
-> extends FormField<Fieldnames> {
-	constructor(field_name: Fieldnames, required: boolean) {
-		super(field_name, required, (_, value) => this.isValueValid(_, value));
-	}
-
-	private async isValueValid(_: BaseContext, value: unknown) {
-		if (
-			(is(value, predicates.string) &&
-				!isNaN(parseFloat(value)) &&
-				parseFloat(value).toString() == value.trim()) ||
-			is(value, predicates.number) ||
-			((is(value, predicates.undefined) || value == "") && !this.required)
-		) {
-			return { valid: true, message: "" };
-		}
-		return { valid: false, message: "Proszę wprowadzić liczbę" };
-	}
-}

package/src/forms/form-fields-list.ts

@@ -1,7 +0,0 @@
-import { FormField } from "./field";
-
-export class FormFieldsList {
-	static getField(fields: FormField[], name: string) {
-		return fields.find((f) => f.name == name);
-	}
-}

package/src/forms/validator.ts

@@ -1,10 +0,0 @@
-import { BaseContext } from "koa";
-import { Field } from "sealious";
-import { FormFieldValidationFn } from "./field";
-
-export function collectionFieldValidator(field: Field): FormFieldValidationFn {
-	return async (ctx: BaseContext, value) => {
-		const { valid, reason } = await field.checkValue(ctx.$context, value, undefined);
-		return { valid, message: reason || (valid ? "Wrong value" : "") };
-	};
-}