@sealcode/sealgen 0.11.8 → 0.12.2

package/dist/utils/exec.js

@@ -0,0 +1,29 @@
+import { spawn } from "child_process";
+async function exec(program, args) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const process = spawn(program, args);
+    process.stdout.on(
+      "data",
+      (data) => stdout += data.toString()
+    );
+    process.stderr.on(
+      "data",
+      (data) => stderr += data.toString()
+    );
+    process.on("close", (exitCode) => {
+      if (exitCode === 0) {
+        resolve({ stdout, stderr, exitCode });
+      } else {
+        console.error([program, ...args].join(" "));
+        console.error(stderr);
+        reject({ stdout, stderr, exitCode });
+      }
+    });
+  });
+}
+export {
+  exec
+};
+//# sourceMappingURL=exec.js.map

package/dist/utils/extract-fields-from-collection.js

@@ -0,0 +1,33 @@
+import _locreq from "locreq";
+import { curryImportPath, exec } from "./utils.js";
+const target_locreq = _locreq(process.cwd());
+import { promises as fs } from "fs";
+async function extract_fields_from_collection(collection_name) {
+  const rel = curryImportPath(target_locreq.resolve("dist/back"));
+  const extractor_code = `import {default as Collection} from "${rel(
+    `./back/collections/${collection_name}.js`
+  )}";
+const c = new Collection();
+const fields = [];
+for (const field_name in c.fields){
+    const field = c.fields[field_name];
+    let type = field.typeName;
+    if(["derived-value", "cached-value"].includes(type)){
+	type = field.virtual_field.typeName
+    }
+    fields.push({name: field_name, type})
+}
+console.log(JSON.stringify(fields));
+`;
+  const extractor_code_path = target_locreq.resolve(
+    "dist/back/___extract_fields.js"
+  );
+  await fs.writeFile(extractor_code_path, extractor_code);
+  const { stdout } = await exec("node", [extractor_code_path]);
+  await fs.unlink(extractor_code_path);
+  return JSON.parse(stdout);
+}
+export {
+  extract_fields_from_collection as default
+};
+//# sourceMappingURL=extract-fields-from-collection.js.map

package/dist/utils/format-external-url.js

@@ -0,0 +1,11 @@
+function formatExternalURL(url) {
+  const trimmed = url.trim();
+  if (!trimmed.toLowerCase().startsWith("https://") || !trimmed.toLowerCase().startsWith("https://")) {
+    return `http://${trimmed}`;
+  }
+  return trimmed;
+}
+export {
+  formatExternalURL
+};
+//# sourceMappingURL=format-external-url.js.map

package/dist/utils/import-path.js

@@ -0,0 +1,23 @@
+import { relative, dirname } from "path";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+function importPath(project_module_path, project_target_path) {
+  let result = relative(
+    dirname(target_locreq.resolve(project_module_path)),
+    target_locreq.resolve(project_target_path).replace(/.tsx?$/, ".js")
+  );
+  if (result[0] != ".") {
+    result = "./" + result;
+  }
+  return result;
+}
+function curryImportPath(project_module_path) {
+  return function(project_target_path) {
+    return importPath(project_module_path, project_target_path);
+  };
+}
+export {
+  curryImportPath,
+  importPath
+};
+//# sourceMappingURL=import-path.js.map

package/dist/utils/input-wrapper.js

@@ -0,0 +1,19 @@
+import { tempstream } from "tempstream";
+function getRequiredClass(isRequired) {
+  return isRequired ? "required" : "";
+}
+function getModifierClasses(modifiers) {
+  return modifiers.map((m) => "form-input__wrapper--" + m).join(" ");
+}
+function inputWrapper(modifiers, input) {
+  return tempstream`<div
+		class="form-input form-input__wrapper ${getModifierClasses(modifiers)}"
+	>
+		${input}
+	</div>`;
+}
+export {
+  getRequiredClass,
+  inputWrapper
+};
+//# sourceMappingURL=input-wrapper.js.map

package/dist/utils/list-collections.js

@@ -0,0 +1,13 @@
+import _locreq from "locreq";
+import { walkDir } from "./walk.js";
+const target_locreq = _locreq(process.cwd());
+async function listCollections() {
+  const files = await walkDir(target_locreq.resolve("src/back/collections"));
+  return files.filter(
+    (f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith("collections.ts")
+  ).map((f) => f.replace(/.ts$/, "").split("/").at(-1) || "").filter((e) => e !== "");
+}
+export {
+  listCollections
+};
+//# sourceMappingURL=list-collections.js.map

package/dist/utils/make-slug.js

@@ -0,0 +1,7 @@
+function makeSlug(t) {
+  return t.replaceAll(/\P{General_Category=Letter}/g, "-").replaceAll(/-+/g, "-");
+}
+export {
+  makeSlug
+};
+//# sourceMappingURL=make-slug.js.map

package/dist/utils/natural-numbers.js

@@ -0,0 +1,9 @@
+function* naturalNumbers(min, max) {
+  for (let i = min; i <= max; i++) {
+    yield i;
+  }
+}
+export {
+  naturalNumbers
+};
+//# sourceMappingURL=natural-numbers.js.map

package/dist/utils/prettier.js

@@ -0,0 +1,15 @@
+import Prettier from "prettier";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+async function getPrettierConfig() {
+  return {
+    ...await Prettier.resolveConfig(
+      target_locreq.resolve("src/back/routes")
+    ),
+    parser: "typescript"
+  };
+}
+export {
+  getPrettierConfig
+};
+//# sourceMappingURL=prettier.js.map

package/dist/utils/question.js

@@ -0,0 +1,20 @@
+import { createInterface } from "readline";
+async function question(text, validator) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  let answer = "";
+  while (answer == "" || !validator(answer)) {
+    answer = await new Promise((resolve) => rl.question(text, resolve));
+    if (!validator(answer)) {
+      console.log("Try again");
+    }
+  }
+  rl.close();
+  return answer;
+}
+export {
+  question
+};
+//# sourceMappingURL=question.js.map

package/dist/utils/render-attributes.js

@@ -0,0 +1,18 @@
+import { attribute } from "../sanitize.js";
+function renderAttributes(attrs) {
+  return Object.entries(attrs).map(([key, value]) => {
+    if (typeof value === "boolean") {
+      if (value) {
+        return key;
+      } else {
+        return "";
+      }
+    } else {
+      return `${key}="${attribute(value)}"`;
+    }
+  }).join(" ");
+}
+export {
+  renderAttributes
+};
+//# sourceMappingURL=render-attributes.js.map

package/dist/utils/sleep.js

@@ -0,0 +1,7 @@
+async function sleep(time) {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+export {
+  sleep
+};
+//# sourceMappingURL=sleep.js.map

package/dist/utils/translate.js

@@ -0,0 +1,12 @@
+function t(ctx, key, props, default_translation) {
+  return (
+    /* HTML */
+    `<span translation-key="${key.replace('"', '\\"')}"
+		>${ctx.$app.getString(key, props, default_translation)}</span
+	>`
+  );
+}
+export {
+  t
+};
+//# sourceMappingURL=translate.js.map

package/dist/utils/url-with-new-params.js

@@ -0,0 +1,8 @@
+import qs from "qs";
+function UrlWithNewParams(ctx, query_params) {
+  return `${ctx.path}?${qs.stringify(query_params)}`;
+}
+export {
+  UrlWithNewParams
+};
+//# sourceMappingURL=url-with-new-params.js.map

package/dist/utils/utils.js

@@ -0,0 +1,28 @@
+function keys(object) {
+  return Object.keys(object);
+}
+import { sleep } from "./sleep.js";
+import { naturalNumbers } from "./natural-numbers.js";
+import { UrlWithNewParams } from "./url-with-new-params.js";
+import { exec } from "./exec.js";
+import { importPath, curryImportPath } from "./import-path.js";
+import { listCollections } from "./list-collections.js";
+import { walkDir } from "./walk.js";
+import { assertThrowsAsync } from "./assert-throws.js";
+export * from "./make-slug.js";
+export * from "./render-attributes.js";
+export * from "./format-external-url.js";
+export * from "./base64.js";
+export {
+  UrlWithNewParams,
+  assertThrowsAsync,
+  curryImportPath,
+  exec,
+  importPath,
+  keys,
+  listCollections,
+  naturalNumbers,
+  sleep,
+  walkDir
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils/walk.js

@@ -0,0 +1,23 @@
+import { promises as fs } from "fs";
+import { resolve } from "path";
+async function walkDir(dir) {
+  const entries = await fs.readdir(dir);
+  let ret = [];
+  for (const entry of entries) {
+    if (entry.includes(".#")) {
+      continue;
+    }
+    const fullpath = resolve(dir, entry);
+    const info = await fs.stat(fullpath);
+    if (info.isDirectory()) {
+      ret = [...ret, ...await walkDir(fullpath)];
+    } else {
+      ret = [...ret, fullpath];
+    }
+  }
+  return ret;
+}
+export {
+  walkDir
+};
+//# sourceMappingURL=walk.js.map

package/dist/vitest.config.js

@@ -0,0 +1,23 @@
+import { defineConfig } from "vitest/config";
+const exclude = ["node_modules", "lib", "dist"];
+var vitest_config_default = defineConfig({
+  test: {
+    testTimeout: 1e4,
+    exclude,
+    globals: true,
+    coverage: {
+      exclude,
+      enabled: true,
+      all: true,
+      include: ["dist/**", "test?(-*).?(c|m)[jt]s?(x)"]
+    },
+    sequence: { setupFiles: "list" },
+    maxConcurrency: 1,
+    pool: "threads",
+    poolOptions: { threads: { maxThreads: 1, minThreads: 1 } }
+  }
+});
+export {
+  vitest_config_default as default
+};
+//# sourceMappingURL=vitest.config.js.map

package/package.json

@@ -1,48 +1,51 @@
 {
 	"name": "@sealcode/sealgen",
-	"version": "0.11.8",
+	"version": "0.12.2",
 	"description": "Module to automate adding routes and collections to a sealious application",
-	"main": "lib/index.js",
+	"main": "dist/index.js",
+	"type": "module",
 	"scripts": {
-		"test": "mocha",
-		"build": "tsc",
+		"build": "node ./build.js",
+		"typecheck": "tsc --noemit",
 		"prepare": "npm run build",
 		"watch": "npm run build -- --watch",
-		"clean-coverage": "rm -rf coverage .nyc_output .xunit",
-		"coverage": "npm run clean-coverage && nyc mocha",
-		"test-reports": "npm run clean-coverage && nyc --reporter clover mocha --reporter xunit --reporter-option output=.xunit",
-		"coverage-html": "npm run test-reports && nyc report --reporter lcov && xdg-open coverage/lcov-report/index.html"
+		"test-cmd": "vitest --config ./src/vitest.config.ts",
+		"test-cmd-once": "vitest run --config ./src/vitest.config.ts",
+		"test": "npm run test-cmd -- --ui",
+		"coverage": "npm run test --coverage",
+		"test-reports": "rm -f .xunit && npm run test-cmd-once -- --coverage --reporter=junit --outputFile=.xunit",
+		"show-coverage": "npm run test-reports;  xdg-open coverage/index.html"
 	},
 	"bin": {
-		"sealgen": "./lib/cli.js"
+		"sealgen": "./dist/cli.js"
 	},
 	"author": "",
 	"license": "ISC",
 	"devDependencies": {
-		"@istanbuljs/nyc-config-typescript": "^1.0.2",
 		"@playwright/test": "^1.30.0",
 		"@types/koa__router": "^12.0.4",
-		"@types/mocha": "^9.0.0",
-		"@types/node": "^18.11.4",
+		"@types/node": "^20.8.4",
 		"@types/prettier": "^2.7.0",
 		"@types/prompts": "^2.0.14",
 		"@types/recursive-readdir": "^2.2.4",
 		"@types/ws": "^8.5.10",
-		"@typescript-eslint/eslint-plugin": "^4.29.3",
-		"@typescript-eslint/parser": "^4.29.3",
+		"@types/yargs": "^17.0.32",
+		"@vitest/coverage-istanbul": "^1.1.0",
+		"@vitest/coverage-v8": "^1.1.0",
+		"@vitest/ui": "^1.1.0",
+		"axios": "^1.6.7",
 		"eslint": "^7.32.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-prettier": "^3.4.1",
 		"eslint-plugin-with-tsc-error": "^0.0.7",
 		"get-port": "^5.1.1",
 		"koa-body": "^5.0.0",
-		"mocha": "^9.2.2",
-		"mri": "^1.2.0",
 		"nyc": "^15.1.0",
 		"playwright": "^1.29.2",
 		"source-map-support": "^0.5.21",
 		"ts-node": "^10.9.1",
 		"typescript": "^4.7",
+		"vitest": "^1.1.0",
 		"wait-port": "^1.0.4"
 	},
 	"types": "./@types/index.d.ts",
@@ -51,10 +54,8 @@
 		"@sealcode/ts-predicates": "^0.4.3",
 		"deepmerge": "^4.3.1",
 		"esbuild": "^0.20.0",
-		"esbuild-sass-plugin": "^2.3.1",
 		"js-convert-case": "^4.2.0",
-		"koa": "^2.13.0",
-		"locreq": "^2.0.2",
+		"locreq": "^3.0.0",
 		"merge": "^2.1.1",
 		"prettier": "^2.7.1",
 		"prompts": "^2.4.2",
@@ -66,7 +67,7 @@
 	},
 	"peerDependencies": {
 		"koa": "^2.13.0",
-		"koa-responsive-image-router": "^0.2.2",
-		"sealious": "^0.17.27"
+		"koa-responsive-image-router": "^0.2.6",
+		"sealious": "^0.17.50"
 	}
 }

package/remove-named-imports.js

@@ -0,0 +1,65 @@
+import fs from "node:fs/promises";
+import { extname } from "node:path";
+
+const generate_names = (function* generate_names() {
+	const base_name = "____unique_import_";
+	let count = 0;
+	while (true) {
+		yield `${base_name}${count}`;
+		count++;
+	}
+})();
+
+export const remove_named_imports = {
+	name: "remove-named-imports", // named imports sometime cause some esm incompatibilities, like the "is a CommonJS module, which may not support all module.exports as named exports." error
+	setup(build) {
+		build.onLoad({ filter: /.*/ }, async ({ path }) => {
+			const named_and_default_regex =
+				/^import\s+((\S+),\s+)?({\s*[^}]+})\s+from\s+("[^"]+");\s*$/gm;
+
+			const old_content = await fs.readFile(path, "utf-8");
+			const contents = old_content.replace(
+				named_and_default_regex,
+				(_, default_import_name, __, all_named, module_path) => {
+					/* eslint-disable */
+					const new_name = generate_names.next().value;
+					const result =
+						`import * as ${new_name} from ${module_path}${
+							default_import_name
+								? `; const ${default_import_name.replace(
+										",",
+										""
+								  )} = ${new_name}.default || ${new_name};`
+								: ""
+						};` +
+						all_named
+							.match(/[a-zA-Z_$][^,}]+/g)
+							.map((importname) => {
+								if (importname.startsWith("default as")) {
+									return `const ${importname.replace(
+										"default as ",
+										""
+									)} = ${new_name}?.default || ${new_name};`;
+								}
+								if (importname.match(/([^{]*)\sas\s([^}]*)/)) {
+									// is "import {asdfas as somethong_else}
+									const [_, original, named] =
+										importname.match(
+											/([^{]*)\sas\s([^}]*)/
+										);
+									return `const ${named} = ${new_name}?.default.${original} || ${new_name}?.${original}`;
+								}
+								return `const ${importname} = ${new_name}?.default?.${importname} || ${new_name}?.${importname};`;
+							})
+							.join("; ");
+					return result;
+					/* eslint-enable */
+				}
+			);
+			return {
+				contents,
+				loader: extname(path) === ".tsx" ? "tsx" : "ts",
+			};
+		});
+	},
+};

package/src/add-collection.ts

@@ -1,9 +1,9 @@
 import { resolve } from "path";
 import _locreq from "locreq";
 import { promises as fs, existsSync } from "fs";
-import { question } from "./utils/question";
-import { collectionTemplate } from "./templates/collection";
-import { generateCollections } from "./generate-collections";
+import { question } from "./utils/question.js";
+import { collectionTemplate } from "./templates/collection.js";
+import { generateCollections } from "./generate-collections.js";
 const target_locreq = _locreq(process.cwd());
 
 export async function addCollection(): Promise<void> {

package/src/add-jdd-component.ts

@@ -1,10 +1,10 @@
 import { resolve } from "path";
 import _locreq from "locreq";
 import { promises as fs, existsSync } from "fs";
-import { question } from "./utils/question";
+import { question } from "./utils/question.js";
 const target_locreq = _locreq(process.cwd());
-import { jddComponentTemplate } from "./templates/jdd-component";
-import { generateComponents } from "./generate-components";
+import { jddComponentTemplate } from "./templates/jdd-component.js";
+import { generateComponents } from "./generate-components.js";
 import { toKebabCase } from "js-convert-case";
 
 export async function addJDDComponent(): Promise<void> {

package/src/add-route.test.ts

@@ -1,20 +1,42 @@
 import { promises as fs } from "fs";
 import { exec, spawn } from "child_process";
-import { promisify } from "util";
 import axios from "axios";
 import waitPort from "wait-port";
 import getPort from "get-port";
 import _locreq from "locreq";
-const target_locreq = _locreq(__dirname);
+const locreq = _locreq(__dirname);
 
-const execAsync = promisify(exec);
+const execAsync = (cmd: string) => {
+	return new Promise<void>((resolve, reject) => {
+		const process = exec(cmd);
 
-const callSealgenBin = () => `node ${target_locreq.resolve("lib/cli.js")}`;
+		console.log("EXECUTING", cmd);
+
+		process?.stdout?.on("data", (data) => {
+			console.log(`stdout: ${data}`);
+		});
+
+		process?.stderr?.on("data", (data) => {
+			console.log(`stdout: ${data}`);
+		});
+
+		process.on("exit", (code) => {
+			if (code == 0) {
+				resolve();
+			} else {
+				reject();
+			}
+		});
+	});
+};
+
+const callSealgenBin = () => `node ${locreq.resolve("dist/cli.js")}`;
 
 describe("add route test", () => {
 	let node_pid = 0;
-	const app_path = "/tmp/sealious-minimal";
-	const container_name = "sealgen-test-mongo";
+	const timestamp = Date.now();
+	const app_path = `/tmp/sealious-minimal-${timestamp}`;
+	const container_name = `sealgen-test-mongo-${timestamp}`;
 	afterEach(async function () {
 		try {
 			if (node_pid != 0) await execAsync(`kill -9 ${node_pid}`);
@@ -28,10 +50,9 @@ describe("add route test", () => {
 	});
 
 	it("creates minimal sealious app", async function () {
-		this.timeout(250000);
 		console.log("\tcloning sealious-minimal...");
 		await execAsync(
-			`git clone https://hub.sealcode.org/source/sealious-minimal.git ${app_path} && cd ${app_path} && git checkout d5abeb9514359dde4`
+			`git clone https://hub.sealcode.org/source/sealious-minimal.git ${app_path} && cd ${app_path} && git checkout 710b873`
 		);
 		console.log("\tinstalling dependencies and sealgen...");
 		await execAsync(
@@ -48,7 +69,14 @@ describe("add route test", () => {
 		await execAsync(`docker run -p ${port}:27017 --name ${container_name} -d mongo:4.4-bionic`);
 		console.log("\trunning app and making request to the generated url...");
 		const env = { ...process.env, SEALIOUS_MONGO_PORT: port.toString() };
-		let app_start = spawn(`node`, [`${app_path}/dist/back/index.js`], {
+		const node_args = [`${app_path}/dist/back/index.js`];
+		console.log(
+			"EXECUTING",
+			`${Object.entries(env)
+				.map(([key, value]) => `${key}=${value}`)
+				.join(" ")} node ${node_args.join(" ")}`
+		);
+		let app_start = spawn(`node`, node_args, {
 			env,
 		});
 		app_start.stdout.on("data", (data) => console.log(data.toString()));
@@ -65,5 +93,5 @@ describe("add route test", () => {
 		if (res.status != 200) {
 			throw new Error("url generated by add-route exists but doesnt return 200");
 		}
-	});
+	}, 250000);
 });

package/src/add-route.ts

@@ -1,11 +1,11 @@
 import { existsSync, promises as fs } from "fs";
 import _locreq from "locreq";
 import { resolve } from "path";
-import { generateRoutes } from "./generate-routes";
-import { testTemplate } from "./templates/route-test";
-import { escape_url_params } from "./utils/escape-url-params";
-import prompts = require("prompts");
-import { Templates } from "./templates/templates";
+import { generateRoutes } from "./generate-routes.js";
+import { testTemplate } from "./templates/route-test.js";
+import { escape_url_params } from "./utils/escape-url-params.js";
+import prompts from "prompts";
+import { Templates } from "./templates/templates.js";
 
 export async function addRoute(
 	params: Partial<{ [key in "action" | "url" | "mode"]: string }>,