@sealcode/sealgen 0.11.7 → 0.12.0

package/dist/generate-collections.js

@@ -0,0 +1,65 @@
+import _locreq from "locreq";
+import * as prettier from "prettier";
+import { promises as fs } from "fs";
+import { assertType, predicates } from "@sealcode/ts-predicates";
+import { getPrettierConfig } from "./utils/prettier.js";
+const target_locreq = _locreq(process.cwd());
+async function extractCollectionClassname(full_file_path) {
+  const file_content = await fs.readFile(full_file_path, "utf-8");
+  const result = /export default class (\w+)/.exec(file_content);
+  if (result === null) {
+    throw new Error("Missing 'export default class' statement?");
+  }
+  return assertType(
+    result[1],
+    predicates.string,
+    `Missing export default class in '${full_file_path}'?`
+  );
+}
+async function generateCollections() {
+  const collections_dir = target_locreq.resolve("src/back/collections");
+  const files = (await fs.readdir(collections_dir)).filter(
+    (f) => !/\.(sub)?test\./.exec(f) && f != "collections.ts" && !f.includes(".#") && f.endsWith(".ts")
+  );
+  const file_data = await Promise.all(
+    files.map(async (file) => {
+      const full_path = target_locreq.resolve(
+        "src/back/collections/" + file
+      );
+      const class_name = await extractCollectionClassname(full_path);
+      return {
+        class_name,
+        file,
+        full_path,
+        urlname: file.replace(".ts", "")
+      };
+    })
+  );
+  const content = `// DO NOT EDIT! This file is generated automaticaly with 'npm run generate-collections'
+import { App } from "sealious";
+
+${file_data.map(
+    ({ class_name, urlname }) => `import _${class_name} from "./${urlname}.js";`
+  ).join("\n")}
+	
+${file_data.map(
+    ({ class_name }) => `export const ${class_name} = new _${class_name}();`
+  ).join("\n")}
+
+export const collections = {
+	...App.BaseCollections,
+${file_data.map(({ class_name, urlname }) => `	"${urlname}": ${class_name},`).join("\n")}
+};`;
+  await fs.writeFile(
+    target_locreq.resolve("src/back/collections/collections.ts"),
+    prettier.format(content, await getPrettierConfig())
+  );
+  console.log(
+    "Successfuly generated new src/back/collections/collections.ts file"
+  );
+}
+export {
+  extractCollectionClassname,
+  generateCollections
+};
+//# sourceMappingURL=generate-collections.js.map

package/dist/generate-components.js

@@ -0,0 +1,41 @@
+import _locreq from "locreq";
+import * as prettier from "prettier";
+import { promises as fs } from "fs";
+import { getPrettierConfig } from "./utils/prettier.js";
+import recursive from "recursive-readdir";
+import path from "path";
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { mkdir } from "fs/promises";
+const target_locreq = _locreq(process.cwd());
+async function generateComponents() {
+  const components_dir = target_locreq.resolve("src/back/jdd-components");
+  await mkdir(components_dir, { recursive: true });
+  const component_names = (await recursive(components_dir)).filter(
+    (c) => c.endsWith(".jdd.tsx")
+  );
+  const component_data = component_names.map(
+    (p) => "./" + path.relative(components_dir, p).replace(/\.[tj]sx?$/, ".js")
+  ).map((relative_path) => {
+    const name = relative_path.match(/\/([^\/]+).jdd/)?.[1];
+    return { name, relative_path };
+  });
+  const content = `// DO NOT EDIT! This file is generated automaticaly with 'npm run generate-components'
+	import { Registry } from "@sealcode/jdd";
+
+	export const registry = new Registry();
+${component_data.map(
+    (c) => `
+	import { ${toPascalCase(c.name)} } from "${c.relative_path}";
+	registry.add("${toKebabCase(c.name)}", ${toPascalCase(c.name)});`
+  ).join("\n")}`;
+  const target = "src/back/jdd-components/components.ts";
+  await fs.writeFile(
+    target_locreq.resolve(target),
+    prettier.format(content, await getPrettierConfig())
+  );
+  console.log(`Successfuly generated new ${target} file`);
+}
+export {
+  generateComponents
+};
+//# sourceMappingURL=generate-components.js.map

package/dist/generate-routes.js

@@ -0,0 +1,90 @@
+import { promises as fs } from "fs";
+import * as prettier from "prettier";
+import { relative } from "path";
+import _locreq from "locreq";
+import { walkDir } from "./utils/walk.js";
+import { importPath } from "./utils/import-path.js";
+import { assertType, predicates } from "@sealcode/ts-predicates";
+import { unescape_url_params } from "./utils/escape-url-params.js";
+import { getPrettierConfig } from "./utils/prettier.js";
+import { Templates } from "./templates/templates.js";
+const target_locreq = _locreq(process.cwd());
+async function extractActionName(full_file_path) {
+  const file_content = await fs.readFile(full_file_path, "utf-8");
+  const result = /export const actionName = "(\w+)"/.exec(file_content);
+  if (result === null) {
+    throw new Error("Missing 'export const actionName' statement?");
+  }
+  return assertType(
+    result[1],
+    predicates.string,
+    "Missing export default class?"
+  );
+}
+function generateURL(actionName, url) {
+  const parts = url.split("/");
+  const params = parts.filter((part) => part.startsWith(":")).map((part) => part.slice(1));
+  if (params.length === 0) {
+    return `export const ${actionName}URL = "${url}";`;
+  }
+  return `export const ${actionName}URL = (${params.map((s) => s + ": string").join(", ")})=>\`${parts.map(
+    (part) => part.startsWith(":") ? "${" + part.slice(1) + "}" : part
+  ).join("/")}\`;
+        ${actionName}URL.params = [${params.map((param) => `"${param}"`).join(",")}];
+        ${actionName}URL.rawURL = "${url}";`;
+}
+async function generateRoutes() {
+  const files = await Promise.all(
+    (await walkDir(target_locreq.resolve("src/back/routes"))).filter(
+      (f) => Object.keys(Templates).some(
+        (key) => f.endsWith(`.${key}.ts`) || f.endsWith(`.${key}.tsx`)
+      )
+    ).map(async (fullpath) => ({
+      fullpath,
+      actionName: await extractActionName(fullpath),
+      url: unescape_url_params(
+        "/" + relative(
+          target_locreq.resolve("src/back/routes"),
+          fullpath
+        ).replace(/\..+/, "") + "/"
+        // trailing slash is important here, as it enables to use the entire path while building relative URLs. For example, while visiting /users/123, the path ./add-photo leads to /users/add-photo. While visiting /users/123/ (note the trailing slash), the path ./add-photo leads to /users/123/add-photo
+      )
+    }))
+  );
+  const routes_content = `// DO NOT EDIT! This file is generated automaticaly with npm run generate-routes
+
+import Router from "@koa/router";
+import { mount } from "@sealcode/sealgen";
+import * as URLs from "./urls.js"
+
+${files.map(
+    ({ actionName, fullpath }) => `import { default as ${actionName} } from "${importPath(
+      target_locreq.resolve("src/back/routes/routes.ts"),
+      fullpath
+    )}";`
+  ).join("\n")}
+
+export default function mountAutoRoutes(router: Router) {
+${files.map(
+    ({ actionName }) => `	mount(router, URLs.${actionName}URL, ${actionName});`
+  ).join("\n")}
+}`;
+  const urls_content = `${files.sort(({ url: url1 }, { url: url2 }) => url1 < url2 ? -1 : 1).map(({ actionName, url }) => generateURL(actionName, url)).join("\n")}
+`;
+  const prettier_config = await getPrettierConfig();
+  await fs.writeFile(
+    target_locreq.resolve("src/back/routes/routes.ts"),
+    prettier.format(routes_content, prettier_config)
+  );
+  await fs.writeFile(
+    target_locreq.resolve("src/back/routes/urls.ts"),
+    prettier.format(urls_content, prettier_config)
+  );
+  console.log(
+    "Successfuly generated new src/back/routes/routes.ts and src/back/routes/urls.ts"
+  );
+}
+export {
+  generateRoutes
+};
+//# sourceMappingURL=generate-routes.js.map

package/dist/hehe.test.js

@@ -0,0 +1,7 @@
+import { hehe } from "./sample-lib.js";
+describe("hehe", () => {
+  it("hehe", () => {
+    hehe.hehe;
+  });
+});
+//# sourceMappingURL=hehe.test.js.map

package/dist/index.js

@@ -0,0 +1,26 @@
+import * as Controls from "./forms/controls/controls.js";
+import * as Field from "./forms/fields/field.js";
+import * as Fields from "./forms/fields/fields.js";
+export * from "./page/mountable.js";
+export * from "./page/page.js";
+export * from "./page/stateful-page.js";
+export * from "./forms/form-types.js";
+export * from "./forms/form.js";
+export * from "./page/props-parser.js";
+export * from "./utils/utils.js";
+export * from "./page/list.js";
+export * from "./page/sealious-list.js";
+export * from "./utils/translate.js";
+import * as sanitize from "./sanitize.js";
+export * from "./forms/multiform.js";
+import * as Components from "./components/components.js";
+export * from "./mount.js";
+export * from "./page/default-list-filters.js";
+export {
+  Components,
+  Controls,
+  Field,
+  Fields,
+  sanitize
+};
+//# sourceMappingURL=index.js.map

package/dist/make-env.js

@@ -0,0 +1,17 @@
+import os from "os";
+import { promises as fs } from "fs";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+async function makeEnv() {
+  const { uid, gid } = os.userInfo();
+  const content = `USER_ID=${uid}
+GROUP_ID=${gid}
+`;
+  const path = target_locreq.resolve(".env");
+  await fs.writeFile(path, content);
+  console.log("wrote .env");
+}
+export {
+  makeEnv
+};
+//# sourceMappingURL=make-env.js.map

package/dist/make-hidden-inputs.js

@@ -0,0 +1,15 @@
+import { tempstream } from "tempstream";
+import { attribute } from "./sanitize.js";
+function makeHiddenInputs(ctx, fields, values, fields_to_skip) {
+  return tempstream`${Object.entries(fields).filter(([key]) => !fields_to_skip.includes(key)).map(
+    ([key, field]) => tempstream`<input
+				type="hidden"
+				name="${key}"
+				value="${field.getValue(ctx, values).then((r) => attribute(JSON.stringify(r.raw) || ""))}"
+			/>`
+  )}`;
+}
+export {
+  makeHiddenInputs
+};
+//# sourceMappingURL=make-hidden-inputs.js.map

package/dist/mount.js

@@ -0,0 +1,66 @@
+import Sealious from "sealious";
+async function handleHtmlPromise(ctx, next) {
+  await next();
+  if (ctx.body instanceof Promise) {
+    ctx.body = await ctx.body;
+  }
+  ctx.set("content-type", "text/html;charset=utf-8");
+}
+function mount(router, url, mountable, use_dummy_app = false) {
+  const raw_url = typeof url === "string" ? url : url.rawURL;
+  const args = use_dummy_app ? [
+    async (ctx, next) => {
+      ctx.$app = {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        Logger: new Proxy(
+          {},
+          {
+            get: (_target, prop) => {
+              if (prop === "info") {
+                return () => {
+                };
+              } else {
+                return () => {
+                };
+              }
+            }
+          }
+        ),
+        getString: (x) => x
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      };
+      await next();
+    },
+    Sealious.Middlewares.parseBody(),
+    handleHtmlPromise
+  ] : [
+    Sealious.Middlewares.extractContext(),
+    Sealious.Middlewares.parseBody(),
+    handleHtmlPromise
+  ];
+  router.use(raw_url, ...args);
+  mountable.init();
+  router.get(raw_url.slice(0, -1), async (ctx, next) => {
+    const url2 = ctx.URL;
+    if (!url2.pathname.endsWith("/")) {
+      url2.pathname += "/";
+      ctx.redirect(url2.href);
+    }
+    await next();
+  });
+  router.use(raw_url, async (ctx, next) => {
+    ctx.set("content-type", "text/html;charset=utf-8");
+    const access_result = await mountable.canAccess(ctx);
+    if (!access_result.canAccess) {
+      ctx.status = 403;
+      ctx.body = access_result.message || "no access";
+      return;
+    }
+    await next();
+  });
+  mountable.mount(router, raw_url);
+}
+export {
+  mount
+};
+//# sourceMappingURL=mount.js.map

package/dist/notifier.js

@@ -0,0 +1,21 @@
+import WebSocket from "ws";
+function make_notifier(port) {
+  const server = new WebSocket.Server({
+    port
+  });
+  let sockets = [];
+  server.on("connection", function(socket) {
+    sockets.push(socket);
+    socket.on("close", function() {
+      sockets = sockets.filter((s) => s !== socket);
+    });
+  });
+  console.log("build notifier listening on websocket at port " + port);
+  return function notify(message) {
+    sockets.forEach((s) => s.send(message));
+  };
+}
+export {
+  make_notifier
+};
+//# sourceMappingURL=notifier.js.map

package/dist/page/access-control.js

@@ -0,0 +1,19 @@
+function peopleWhoCan(action, collection) {
+  return async function(ctx) {
+    const policy = collection.getPolicy(action);
+    const result = await policy.check(ctx.$context);
+    if (!result) {
+      ctx.status = 403;
+      return { canAccess: false, message: "Not allowed" };
+    }
+    if (!result.allowed) {
+      ctx.status = 403;
+      return { canAccess: false, message: result.reason };
+    }
+    return { canAccess: true, message: "" };
+  };
+}
+export {
+  peopleWhoCan
+};
+//# sourceMappingURL=access-control.js.map

package/dist/page/default-list-filters.js

@@ -0,0 +1,46 @@
+const BooleanListFilter = (value, field) => {
+  return (
+    /* HTML */
+    `<label>
+		${field.name}
+		<select name="filter[${field.name}]" autocomplete="off">
+			<option value="true" ${value == "true" ? "selected" : ""}>
+				True
+			</option>
+			<option value="false" ${value == "false" ? "selected" : ""}>
+				False
+			</option>
+			<option
+				value=""
+				${value == "null" || value == "" || value == "undefined" || value == void 0 ? "selected" : ""}
+			>
+				-
+			</option>
+		</select>
+	</label>`
+  );
+};
+const SimpleTextFilter = (value, field) => {
+  return (
+    /* HTML */
+    `<label>
+		${field.name}
+		<input
+			type="text"
+			name="${field.name}"
+			${value ? `value="${value}"` : value}
+		/>
+	</label>`
+  );
+};
+const DefaultListFilters = {
+  boolean: BooleanListFilter,
+  text: SimpleTextFilter,
+  fallback: SimpleTextFilter
+};
+export {
+  BooleanListFilter,
+  DefaultListFilters,
+  SimpleTextFilter
+};
+//# sourceMappingURL=default-list-filters.js.map

package/dist/page/list.js

@@ -0,0 +1,199 @@
+import { tempstream } from "tempstream";
+import { Page } from "./page.js";
+import { naturalNumbers, UrlWithNewParams } from "../utils/utils.js";
+import { makeHiddenInputs } from "../make-hidden-inputs.js";
+import qs from "qs";
+import { NumberField } from "../forms/fields/number.js";
+import { SimpleFormField } from "../forms/fields/simple-form-field.js";
+const BasePagePropsShape = {};
+const BaseListPageFields = {
+  page: new NumberField(false, 1),
+  itemsPerPage: new NumberField(false, 12),
+  sort: new SimpleFormField(false)
+};
+const SORT_SEPARATOR = ":";
+function decodeSort(s) {
+  if (typeof s !== "string" || !s.includes(SORT_SEPARATOR)) {
+    return null;
+  }
+  let order = s.split(SORT_SEPARATOR)[1];
+  const field = s.split(SORT_SEPARATOR)[0];
+  if (order !== "asc" && order !== "desc") {
+    order = "asc";
+    return {
+      field,
+      order
+    };
+  } else {
+    return { field, order };
+  }
+}
+function encodeSort(field, order) {
+  return [field, order].join(SORT_SEPARATOR);
+}
+class ListPage extends Page {
+  constructor() {
+    super(...arguments);
+    this.filterFields = {};
+    this.filterControls = [];
+  }
+  init() {
+    super.init();
+    for (const [fieldname, field] of Object.entries(this.filterFields)) {
+      field.init(fieldname);
+    }
+  }
+  renderListContainer(_, content) {
+    return tempstream`<div>${content}</div>`;
+  }
+  async getPaginationConfig(ctx) {
+    const values = await this.extractRawValues(ctx);
+    const { parsed: page } = await this.fields.page.getValue(ctx, values);
+    const { parsed: itemsPerPage } = await this.fields.itemsPerPage.getValue(ctx, values);
+    return { page, itemsPerPage };
+  }
+  async renderItems(ctx, values, items) {
+    if (!values) {
+      values = await this.extractRawValues(ctx);
+    }
+    const { itemsPerPage, page } = await this.getPaginationConfig(ctx);
+    const items_promise = this.getItems(ctx, page, itemsPerPage, values);
+    return tempstream`${(items ? Promise.resolve(items) : items_promise).then(
+      (items2) => items2.map((item, index) => this.renderItem(ctx, item, index))
+    )}`;
+  }
+  async render(ctx) {
+    const values = await this.extractRawValues(ctx);
+    return tempstream`${this.renderPagination(ctx, values)}
+			  ${this.renderFilters(ctx)}
+${this.renderListContainer(ctx, this.renderItems(ctx, values))}`;
+  }
+  async renderPagination(ctx, values) {
+    const { itemsPerPage, page } = await this.getPaginationConfig(ctx);
+    const totalIems = await this.getTotalPages(ctx, itemsPerPage, values);
+    return tempstream`<div class="list-pagination">
+			<div class="list-pagination__left">
+				${page > 1 ? this.renderPageButton(ctx, 1, "Pierwsza strona") : ""}
+				${page > 1 ? this.renderPageButton(ctx, page - 1, "Poprzednia strona") : ""}
+			</div>
+			<div class="list-pagination__center">
+				<select
+					title="choose page"
+					onchange="if (this.value) Turbo.visit(this.value)"
+				>
+					${Array.from(naturalNumbers(1, totalIems)).map(
+      (n) => (
+        /* HTML */
+        `<option
+							value="${UrlWithNewParams(
+          ctx,
+          //eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          this.propsParser.overwriteProp(ctx, {
+            page: n
+          })
+        )}"
+							${page === n ? "selected" : ""}
+						>
+							${n}
+						</option>`
+      )
+    )}
+				</select>
+			</div>
+			<div class="list-pagination__right">
+				${page < totalIems ? this.renderPageButton(ctx, page + 1, "Nast\u0119pna strona") : ""}
+				${page < totalIems ? this.renderPageButton(ctx, totalIems, "Ostatnia strona") : ""}
+			</div>
+		</div>`;
+  }
+  renderPageButton(ctx, page, text) {
+    return (
+      /* HTML */
+      `<a
+			href="${UrlWithNewParams(
+        ctx,
+        //eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        this.propsParser.overwriteProp(ctx, {
+          page
+        })
+      )}"
+			>${text}</a
+		>`
+    );
+  }
+  async getFilterValues(ctx) {
+    const filter = {};
+    const raw_values = await this.extractRawValues(ctx);
+    for (const [fieldname, field] of Object.entries(this.filterFields)) {
+      const { parsed } = await field.getValue(ctx, raw_values);
+      filter[fieldname] = field.mapToFilter(parsed);
+    }
+    return filter;
+  }
+  async getSort(ctx) {
+    const { sort } = await this.extractRawValues(ctx);
+    const decoded = decodeSort(sort);
+    if (decoded === null) {
+      return this.getDefaultSort(ctx);
+    } else {
+      return decoded;
+    }
+  }
+  makeSortLink(ctx, field, order) {
+    const url = new URL(ctx.url, "https://example.com");
+    const params = qs.parse(url.search.slice(1));
+    params.sort = encodeSort(field, order);
+    url.search = qs.stringify(params);
+    return url.pathname + url.search;
+  }
+  async renderFilters(ctx) {
+    const values = await this.extractRawValues(ctx);
+    return tempstream`<form method="GET">
+			${makeHiddenInputs(ctx, this.fields, values, [
+      "page",
+      ...Object.values(this.filterFields).map((f) => f.name)
+    ])}
+			${this.filterControls.map((control) => {
+      return control.render(
+        this.makeFormControlContext(
+          ctx,
+          { raw_values: values, messages: [] },
+          false
+        )
+      );
+    })}
+		</form>`;
+  }
+  async renderHeading(ctx, field, label = field) {
+    const current_sort = await this.getSort(ctx);
+    const current_order = current_sort?.field == field ? current_sort.order : null;
+    const order = current_order == "desc" ? "asc" : "desc";
+    return (
+      /* HTML */
+      `<th>
+			<a href="${this.makeSortLink(ctx, field, order)}"
+				>${label}
+				${current_order && (current_order == "asc" ? "\u2191" : "\u2193") || ""}</a
+			>
+		</th>`
+    );
+  }
+  getDefaultSort(_) {
+    return null;
+  }
+  renderTableHead(ctx, fields) {
+    return tempstream`<thead>
+			<tr>
+				${fields.map(
+      ({ label, field }) => this.renderHeading(ctx, field, label)
+    )}
+			</tr>
+		</thead>`;
+  }
+}
+export {
+  BaseListPageFields,
+  BasePagePropsShape,
+  ListPage
+};
+//# sourceMappingURL=list.js.map