@sealcode/sealgen 0.2.1 → 0.2.2

package/src/page/page.ts

@@ -0,0 +1,31 @@
+import Router from "@koa/router";
+import { BaseContext } from "koa";
+
+import { Templatable, tempstream } from "tempstream";
+
+export type PageErrorMessage = { type: "access" | "internal"; message: string };
+
+export interface Mountable {
+	mount: (router: Router, path: string) => void;
+	canAccess: (ctx: BaseContext) => Promise<{ canAccess: boolean; message: string }>;
+	renderError(ctx: BaseContext, error: PageErrorMessage): Promise<Templatable>;
+}
+
+export abstract class Page implements Mountable {
+	mount(router: Router, path: string) {
+		router.get(path, async (ctx) => {
+			ctx.body = await this.render(ctx);
+		});
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async canAccess(_: BaseContext) {
+		return { canAccess: true, message: "" };
+	}
+
+	async renderError(_: BaseContext, error: PageErrorMessage) {
+		return tempstream/* HTML */ `<div>${error.message}</div>`;
+	}
+
+	public abstract render(ctx: BaseContext): Promise<Templatable>;
+}

package/src/page/props-parser.ts

@@ -0,0 +1,99 @@
+import {
+	hasShape,
+	predicates,
+	Shape,
+	ShapeToType,
+} from "@sealcode/ts-predicates";
+
+import { BaseContext } from "koa";
+import merge from "merge";
+import { BasePageProps } from "./list";
+
+export type EncodedProps = Record<string, unknown>;
+
+// the intention here is to sometime in the future be able to store multiple frames on one document, so props for each frame will be in a different namespace, and parsers are going to help with that
+
+function parseStringValues<TheShape extends Shape>(
+	shape: TheShape,
+	values: Record<string, string>
+): ShapeToType<TheShape> {
+	const result: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(values)) {
+		if (!(key in shape)) {
+			continue;
+		}
+		const predicate = shape[key];
+		if (predicate == predicates.number) {
+			result[key] = parseFloat(value);
+		} else {
+			result[key] = value;
+		}
+	}
+	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+	return result as ShapeToType<TheShape>;
+}
+
+export abstract class PagePropsParser<PropsType extends BasePageProps> {
+	abstract decode(ctx: BaseContext): PropsType;
+	abstract encode(props: PropsType): EncodedProps;
+	abstract getHTMLInputName(prop_name: string): string;
+
+	constructor(
+		public propsShape: Shape,
+		public defaultValues: Partial<PropsType>
+	) {}
+
+	overwriteProp(
+		ctx: BaseContext,
+		new_props: Partial<PropsType>
+	): EncodedProps {
+		const result = {};
+		merge.recursive(result, this.decode(ctx), new_props);
+		return result;
+	}
+
+	makeHiddenInputs(values: PropsType, fields_to_skip: string[]): string {
+		return Object.entries(values)
+			.filter(([key]) => !fields_to_skip.includes(key))
+			.map(
+				([key, value]: [string, string | number]) =>
+					/* HTML */ `<input
+						type="hidden"
+						name="${key}"
+						value="${value}"
+					/>`
+			)
+			.join(" ");
+	}
+
+	getDefaultValue<Key extends keyof PropsType>(
+		key: Key
+	): PropsType[Key] | undefined {
+		return this.defaultValues[key];
+	}
+}
+
+export class AllQueryParams<
+	PropsType extends BasePageProps
+> extends PagePropsParser<PropsType> {
+	decode(ctx: BaseContext): PropsType {
+		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+		const query = parseStringValues(this.propsShape, {
+			...this.defaultValues,
+			...ctx.query,
+		} as unknown as Record<string, string>);
+		if (!hasShape(this.propsShape, query)) {
+			throw new Error("Wrong props shape");
+		}
+		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+		return query as PropsType;
+	}
+
+	encode(props: PropsType): Record<string, unknown> {
+		return props;
+	}
+
+	getHTMLInputName(prop_name: string): string {
+		return prop_name;
+	}
+}

package/src/templates/list.ts

@@ -22,7 +22,7 @@ export const listTemplate = async (
 		collection[0].toLocaleUpperCase() + collection.slice(1);
 	const rel = curryImportPath(newfilefullpath);
 	return `import { BaseContext } from "koa";
-import { CollectionItem, Middlewares } from "sealious";
+import { CollectionItem } from "sealious";
 import { tempstream } from "tempstream";
 import { ${uppercase_collection} } from "${rel(
 		"src/back/collections/collections"

package/src/utils/list-collections.ts

@@ -1,9 +1,9 @@
 import _locreq from "locreq";
-import { walk } from "./walk";
+import { walkDir } from "./walk";
 const target_locreq = _locreq(process.cwd());
 
 export async function listCollections(): Promise<string[]> {
-	const files = await walk(target_locreq.resolve("src/back/collections"));
+	const files = await walkDir(target_locreq.resolve("src/back/collections"));
 	return files
 		.filter(
 			(f) =>

package/src/utils/natural-numbers.ts

@@ -0,0 +1,5 @@
+export function* naturalNumbers(min: number, max: number) {
+	for (let i = min; i <= max; i++) {
+		yield i;
+	}
+}

package/src/utils/sleep.ts

@@ -0,0 +1,3 @@
+export async function sleep(time: number) {
+	return new Promise((resolve) => setTimeout(resolve, time));
+}

package/src/utils/url-with-new-params.ts

@@ -0,0 +1,9 @@
+import { BaseContext } from "koa";
+import qs from "qs";
+
+export function UrlWithNewParams(
+	ctx: BaseContext,
+	query_params: Record<string, unknown>
+): string {
+	return `${ctx.path}?${qs.stringify(query_params)}`;
+}

package/src/utils/utils.ts

@@ -0,0 +1,10 @@
+export type Awaited<T> = T extends Promise<infer U> ? U : T;
+export type UnwrapArray<T> = T extends Array<infer U> ? U : T;
+
+export { sleep } from "./sleep";
+export { naturalNumbers } from "./natural-numbers";
+export { UrlWithNewParams } from "./url-with-new-params";
+export { exec } from "./exec";
+export { importPath, curryImportPath } from "./import-path";
+export { listCollections } from "./list-collections";
+export { walkDir } from "./walk";

package/src/utils/walk.ts

@@ -1,7 +1,7 @@
 import { promises as fs } from "fs";
 import { resolve } from "path";
 
-export async function walk(dir: string): Promise<string[]> {
+export async function walkDir(dir: string): Promise<string[]> {
 	const entries = await fs.readdir(dir);
 	let ret: string[] = [];
 	for (const entry of entries) {
@@ -11,7 +11,7 @@ export async function walk(dir: string): Promise<string[]> {
 
 		if (info.isDirectory()) {
 			// eslint-disable-next-line no-await-in-loop
-			ret = [...ret, ...(await walk(fullpath))];
+			ret = [...ret, ...(await walkDir(fullpath))];
 		} else {
 			ret = [...ret, fullpath];
 		}

package/tsconfig.json

@@ -14,8 +14,11 @@
 		"allowJs": true,
 		"declarationDir": "@types",
 		"resolveJsonModule": true,
-		"sourceMap": true
+		"sourceMap": true,
+		"allowSyntheticDefaultImports": true,
+		"keyofStringsOnly": true,
+		"skipLibCheck": true
 	},
 	"include": ["src/**/*"],
-	"exclude": ["src/**/*.test.ts"]
+	"exclude": ["src/**/*.test.ts", "node_modules/**"]
 }

package/src/tsconfig.json

@@ -1,18 +0,0 @@
-{
-	"compilerOptions": {
-		"module": "ESNext",
-		"moduleResolution": "node",
-		"noImplicitAny": true,
-		"noImplicitThis": true,
-		"strictNullChecks": true,
-		"target": "ES2020",
-		"lib": ["es6", "esnext"],
-		"outDir": "../../dist/scripts",
-		"checkJs": true,
-		"allowJs": true,
-		"resolveJsonModule": true,
-		"sourceMap": true,
-		"skipLibCheck": true
-	},
-	"include": ["./**/*", "./*"]
-}