sasat 0.22.0 → 0.22.2

package/dist/cli/index.mjs

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+import { A as writeYmlFile, C as Directory, E as defaultConf, O as mkDirIfNotExist, S as capitalizeFirstLetter, T as config, _ as Console, a as getDbClient, f as getMigrationFileNames, g as defaultGQLOption, h as columnTypeToGqlPrimitive, i as compileMigrationFiles, k as writeCurrentSchema, l as defaultColumnOption, n as DataStoreHandler, p as CodeGen_v2, r as createCurrentMigrationDataStore, t as migrate, u as SqlString, w as DBColumnTypes, x as camelize } from "../migrate-Cbj2OVbY.mjs";
+import * as fs$1 from "node:fs";
+import fs from "node:fs";
+import path, { join } from "node:path";
+import { cac } from "cac";
+//#region src/cli/commands/createMigration.ts
+const getMigrationFile = (className) => `import { SasatMigration, MigrationStore } from "sasat";
+
+export default class ${capitalizeFirstLetter(className)} implements SasatMigration {
+
+  up: (store: MigrationStore) => void = store => {
+
+  };
+
+  down: (store: MigrationStore) => void = store => {
+    throw new Error('Down is not implemented on ${className}');
+  };
+}
+`;
+const createMigrationFile = (migrationName) => {
+	const date = /* @__PURE__ */ new Date();
+	const pad = (val) => val.toString().padStart(2, "0");
+	const fileName = date.getFullYear() + pad(date.getMonth() + 1) + pad(date.getDate()) + `_` + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds()) + migrationName;
+	const outDir = join(config().migration.dir);
+	mkDirIfNotExist(outDir);
+	fs$1.writeFileSync(join(outDir, fileName) + ".ts", getMigrationFile(migrationName));
+	return fileName;
+};
+const createMigration = (args) => {
+	if (!args) {
+		Console.error("missing argument migration name");
+		return;
+	}
+	if (!/^[$A-Za-z_][0-9A-Za-z_]+$/.test(args)) {
+		Console.error("migration name should be match /^[$A-Za-z_][0-9A-Za-z_]+$/");
+		return;
+	}
+	Console.success(createMigrationFile(args) + " Successfully created");
+};
+//#endregion
+//#region src/db/sql/createTable/createTableParser.ts
+const splitArray = (array, callback) => {
+	const indexes = [];
+	array.forEach((it, i) => {
+		if (callback(it)) indexes.push(i);
+	});
+	let prev = 0;
+	const result = [];
+	indexes.forEach((it) => {
+		result.push(array.slice(prev, it));
+		prev = it + 1;
+	});
+	result.push(array.slice(prev, array.length));
+	return result;
+};
+const isParenToken = (token) => {
+	return token.kind === "Paren";
+};
+var CreateTableParser = class {
+	constructor(tokens) {
+		this.tokens = tokens;
+		this.parse = () => {
+			const parenStart = this.findIndex("separator", "(", this.tokens);
+			this.result.tableName = this.tokens[parenStart - 1].value;
+			splitArray(this.resolveParen().find((it) => it.kind === "Paren").tokens, (token) => token.kind === "separator" && token.value === ",").forEach((it) => {
+				const kindIncludes = (kind) => !!it.find((it) => it.kind === kind);
+				if (kindIncludes("PRIMARY")) return this.parsePrimary(it);
+				if (kindIncludes("UNIQUE")) return this.parseUnique(it);
+				if (kindIncludes("FOREIGN")) return this.parseFkey(it);
+				if (kindIncludes("KEY") || kindIncludes("INDEX")) return this.parseIndex(it);
+				const kind = it[0].kind;
+				if (kind === "identifier" || kind === "string") return this.parseColumn(it);
+				throw new Error("fail to parse sql");
+			});
+			return this.result;
+		};
+		this.normalizeFieldName = (fieldName) => {
+			return /^[0-9].*/.test(fieldName) ? "_" + fieldName : fieldName;
+		};
+		this.result = {
+			tableName: "",
+			columns: [],
+			primaryKey: [],
+			uniqueKeys: [],
+			indexes: [],
+			gqlOption: defaultGQLOption(),
+			virtualRelations: []
+		};
+	}
+	resolveParen() {
+		const resolveParen = (tokens) => {
+			const result = [];
+			for (let i = 0; i < tokens.length; i++) {
+				const token = tokens[i];
+				if (token.kind === "separator" && token.value === "(") {
+					const endParen = this.findEndOfParenIndex(tokens, i);
+					result.push({
+						kind: "Paren",
+						tokens: resolveParen(tokens.slice(i + 1, endParen)),
+						value: ""
+					});
+					i = endParen;
+					continue;
+				}
+				result.push(token);
+			}
+			return result;
+		};
+		return resolveParen(this.tokens);
+	}
+	parseColumn(tokens) {
+		const columnName = tokens[0].value;
+		const type = tokens[1].value.toLowerCase();
+		const gqlType = columnTypeToGqlPrimitive(type);
+		const defaultTokenIndex = tokens.findIndex((it) => it.kind === "DEFAULT");
+		const getDefaultValue = () => {
+			if (defaultTokenIndex === -1) return void 0;
+			const next = tokens[defaultTokenIndex + 1];
+			if (next.kind === "NULL") return void 0;
+			if (next.kind === "number" || gqlType === "Float" || gqlType === "Int") return +next.value;
+			if (next.kind === "string") return next.value;
+		};
+		const defaultCurrentTimeStamp = defaultTokenIndex !== -1 && tokens[defaultTokenIndex + 1].kind === "identifier" && tokens[defaultTokenIndex + 1].value.toUpperCase() === "CURRENT_TIMESTAMP";
+		const isOnUpdate = () => {
+			return tokens[tokens.findIndex((it) => it.kind === "UPDATE") + 1].value.toUpperCase() === "CURRENT_TIMESTAMP";
+		};
+		const isNotNull = () => {
+			let prevIsNot = false;
+			return tokens.some((it) => {
+				if (prevIsNot && it.kind === "NULL") return true;
+				prevIsNot = it.kind === "NOT";
+				return false;
+			});
+		};
+		const identifiers = tokens.filter((it) => it.kind === "identifier");
+		const length = tokens[2] && isParenToken(tokens[2]) ? tokens[2].tokens[0]?.value : void 0;
+		const scale = tokens[2] && isParenToken(tokens[2]) ? tokens[2].tokens[1]?.value : void 0;
+		const column = {
+			hasReference: false,
+			columnName,
+			fieldName: this.normalizeFieldName(camelize(tokens[0].value)),
+			type,
+			notNull: isNotNull(),
+			default: getDefaultValue(),
+			zerofill: identifiers.some((it) => it.value.toLowerCase() === "zerofill"),
+			signed: identifiers.some((it) => it.value.toLowerCase() === "unsigned") ? false : identifiers.some((it) => it.value.toLowerCase() === "signed") ? true : void 0,
+			autoIncrement: tokens.some((it) => it.kind === "AUTO_INCREMENT"),
+			length: length !== void 0 ? +length : void 0,
+			scale: scale !== void 0 ? +scale : void 0,
+			defaultCurrentTimeStamp,
+			onUpdateCurrentTimeStamp: isOnUpdate(),
+			option: defaultColumnOption
+		};
+		if (column.default === ".nan" || Number.isNaN(column.default)) console.error(column);
+		this.result.columns.push(column);
+		if (tokens.some((it) => it.kind === "PRIMARY")) this.result.primaryKey = [columnName];
+		if (tokens.some((it) => it.kind === "UNIQUE")) this.result.uniqueKeys.push([columnName]);
+	}
+	parsePrimary(tokens) {
+		const paren = tokens[tokens.findIndex((it) => it.kind === "KEY") + 1];
+		this.result.primaryKey = paren.tokens.filter((it) => it.kind !== "separator").map((it) => it.value);
+	}
+	parseUnique(tokens) {
+		const paren = tokens.find((it) => it.kind === "Paren");
+		this.result.uniqueKeys.push(paren.tokens.filter((it) => it.kind !== "separator").map((it) => it.value));
+	}
+	parseIndex(tokens) {
+		const paren = tokens.find((it) => it.kind === "Paren");
+		this.result.indexes.push({
+			constraintName: tokens[1].value,
+			columns: paren.tokens.filter((it) => it.kind !== "separator" && it.kind !== "Paren").map((it) => it.value)
+		});
+	}
+	parseFkey(tokens) {
+		const columnName = tokens[tokens.findIndex((it) => it.kind === "FOREIGN") + 2].tokens[0].value;
+		const refIndex = tokens.findIndex((it) => it.kind === "REFERENCES" && it.value === "REFERENCES");
+		const targetTable = tokens[refIndex + 1].value;
+		const targetColumn = tokens[refIndex + 2].tokens[0].value;
+		let onDelete;
+		let onUpdate;
+		tokens.map((it, i) => it.kind === "ON" ? i : 0).filter((it) => it !== 0).forEach((it) => {
+			const action = () => {
+				let name = tokens[it + 2].value.toUpperCase();
+				if (name === "SET" || name === "NO") name += tokens[it + 3].value.toUpperCase();
+				return name;
+			};
+			if (tokens[it + 1].kind === "DELETE") onDelete = action();
+			if (tokens[it + 1].kind === "UPDATE") onUpdate = action();
+		});
+		const isColumnUnique = this.result.uniqueKeys.filter((it) => it.length === 1).find((it) => it[0] === columnName);
+		const sameTableRefs = this.result.columns.filter((it) => it.hasReference && it.reference.parentTable === targetTable);
+		const reference = {
+			parentTable: targetTable,
+			parentColumn: targetColumn,
+			columnName,
+			relation: isColumnUnique ? "OneOrZero" : "Many",
+			relationName: sameTableRefs.length !== 0 ? targetTable + sameTableRefs.length : void 0,
+			onUpdate,
+			onDelete
+		};
+		this.result.columns = this.result.columns.map((it) => it.columnName === columnName ? {
+			...it,
+			hasReference: true,
+			reference
+		} : it);
+	}
+	findIndex(kind, value, tokens) {
+		return tokens.findIndex((it) => it.kind === kind && value === it.value);
+	}
+	findEndOfParenIndex(tokens, startParenIndex) {
+		let opened = 1;
+		for (let i = startParenIndex + 1; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (token.kind === "separator") {
+				if (token.value === ")") {
+					opened -= 1;
+					if (opened === 0) return i;
+				} else if (token.value === "(") opened += 1;
+			}
+		}
+		throw new Error("Closing Parenthesis Not Found");
+	}
+};
+//#endregion
+//#region src/db/sql/createTable/lexer/lexer2.ts
+var Lexer2 = class {
+	constructor(str, rules, separators, operators, whiteSpaces = /([ \t\n])/) {
+		this.rules = rules;
+		this.separators = separators;
+		this.operators = operators;
+		this.whiteSpaces = whiteSpaces;
+		this.index = 0;
+		this.tokens = [];
+		this.chars = str.split("");
+	}
+	isTerminated(value, terminators) {
+		const separator = (value) => this.separators.includes(value);
+		const operator = (value) => this.operators.some((it) => it.startsWith(value));
+		const whiteSpace = (value) => this.whiteSpaces.test(value);
+		return terminators.some((it) => {
+			switch (it) {
+				case "operator": return operator(value);
+				case "separator": return separator(value);
+				case "whitespace": return whiteSpace(value);
+				default: return false;
+			}
+		});
+	}
+	lex() {
+		let value = this.read();
+		do
+			value = this.exec(value);
+		while (value.hasNext);
+		return this.tokens;
+	}
+	findOperator(current) {
+		const operator = (value) => ({
+			kind: "operator",
+			value
+		});
+		if (!current.hasNext) return this.operators.includes(current.value) ? operator(current.value) : void 0;
+		let operators = this.operators.filter((it) => it.startsWith(current.value));
+		let state = current.value;
+		if (operators.length === 1) return operator(state);
+		while (operators.length !== 0) {
+			if (!current.hasNext) return operator(state);
+			current = this.read();
+			state += current.value;
+			operators = operators.filter((it) => it.startsWith(state));
+			if (operators.length === 1) return operator(state);
+		}
+		if (state.length > 1) return operator(state.slice(0, -1));
+	}
+	exec(current) {
+		const currentIndex = this.index;
+		if (this.whiteSpaces.test(current.value)) return this.read();
+		if (this.separators.includes(current.value)) {
+			this.tokens.push({
+				kind: "separator",
+				value: current.value
+			});
+			return this.read();
+		}
+		const op = this.findOperator(current);
+		if (op) {
+			this.tokens.push(op);
+			this.index = currentIndex + op.value.length - 1;
+			return this.read();
+		}
+		this.index = currentIndex;
+		for (let i = 0; i < this.rules.length; i++) {
+			const rule = this.rules[i];
+			if (!rule.start.test(current.value)) continue;
+			let terminated = false;
+			let value;
+			const next = () => {
+				value = this.read();
+				terminated = this.isTerminated(value.value, rule.terminator);
+				return {
+					terminated,
+					...value
+				};
+			};
+			const result = rule.fn(current.value, next);
+			if (!result) {
+				this.index = currentIndex;
+				continue;
+			}
+			this.tokens.push(result);
+			if (terminated && value) return value;
+			return this.read();
+		}
+		throw new Error("No Rule Matched");
+	}
+	read() {
+		const char = this.chars[this.index] || "";
+		this.index += 1;
+		return {
+			hasNext: this.chars.length > this.index,
+			value: char
+		};
+	}
+};
+//#endregion
+//#region src/db/sql/createTable/lexer/rules.ts
+const createStringLiteralRule = (literalInitializer) => {
+	return {
+		start: literalInitializer,
+		terminator: [],
+		fn: (start, next) => {
+			let literal = "";
+			let isEscape = false;
+			let v;
+			do {
+				v = next();
+				if (!isEscape && v.value === start) return {
+					kind: "string",
+					value: literal
+				};
+				literal += v.value;
+				isEscape = !isEscape && v.value === "\\";
+			} while (v.hasNext);
+			throw new Error("Non Terminated String");
+		}
+	};
+};
+const numberLiteral = {
+	start: /[0-9]/,
+	terminator: [
+		"separator",
+		"whitespace",
+		"operator"
+	],
+	fn: (start, next) => {
+		let literal = start;
+		let v;
+		do {
+			v = next();
+			if (v.terminated) break;
+			literal += v.value;
+		} while (v.hasNext);
+		if (!Number.isFinite(+literal)) throw new Error("fail to read number");
+		return {
+			kind: "number",
+			value: literal
+		};
+	}
+};
+const createKeywordRule = (keywords, ignoreCase = false) => {
+	return {
+		start: /./,
+		terminator: ["whitespace", "separator"],
+		fn: (start, next) => {
+			let str = ignoreCase ? start.toUpperCase() : start;
+			let words = keywords.map((it) => typeof it === "string" ? {
+				kind: "keyword",
+				value: it
+			} : {
+				...it,
+				value: it.value
+			});
+			if (ignoreCase) words = words.map((it) => ({
+				...it,
+				value: it.value.toUpperCase()
+			}));
+			let v;
+			while (true) {
+				v = next();
+				if (v.terminated && words.find((it) => it.value === str)) return {
+					kind: words.find((it) => it.value === str).kind,
+					value: str
+				};
+				str += ignoreCase ? v.value.toUpperCase() : v.value;
+				words = words.filter((it) => it.value.startsWith(str));
+				if (words.length === 0) return;
+			}
+		}
+	};
+};
+const Rules = {
+	createStringLiteralRule,
+	numberLiteral,
+	createKeywordRule,
+	identifier: {
+		start: /[^0-9]/,
+		terminator: [
+			"separator",
+			"whitespace",
+			"operator"
+		],
+		fn: (start, next) => {
+			let value = start;
+			let v;
+			do {
+				v = next();
+				if (v.terminated) break;
+				value += v.value;
+			} while (v.hasNext);
+			return {
+				kind: "identifier",
+				value
+			};
+		}
+	}
+};
+//#endregion
+//#region src/db/sql/createTable/lexer/createSimpleLexer.ts
+const createSimpleLexer = (str, keywords, ignoreKeywordCase, separators, operators = []) => new Lexer2(str, [
+	Rules.createStringLiteralRule(/['"`]/),
+	Rules.numberLiteral,
+	Rules.createKeywordRule(keywords, ignoreKeywordCase),
+	Rules.identifier
+], separators, operators);
+//#endregion
+//#region src/db/sql/createTable/lexer/createTableLexer.ts
+const separators = [
+	"(",
+	")",
+	","
+];
+const keywords = [
+	"CREATE",
+	"TABLE",
+	"PRIMARY",
+	"KEY",
+	"UNIQUE",
+	"FOREIGN",
+	"NOT",
+	"NULL",
+	"DEFAULT",
+	"AUTO_INCREMENT",
+	"ON",
+	"UPDATE",
+	"DELETE",
+	"REFERENCES",
+	"CONSTRAINT"
+].map((it) => ({
+	kind: it,
+	value: it
+}));
+const createTableLexer = (str) => {
+	return createSimpleLexer(str, keywords, true, separators, ["="]);
+};
+//#endregion
+//#region src/db/sql/createTable/createTableSerializer.ts
+const serializeCreateTable = (str) => {
+	return new CreateTableParser(createTableLexer(str).lex()).parse();
+};
+//#endregion
+//#region src/cli/commands/dumpDb.ts
+const dumpDB = async () => {
+	const con = getDbClient();
+	try {
+		const tables = await con.rawQuery("show tables").then((it) => it.flatMap((it) => Object.values(it)));
+		const serialized = await Promise.all(tables.map((table) => {
+			return con.rawQuery("show create table " + SqlString.escapeId(table)).then((it) => it[0]["Create Table"]).then(serializeCreateTable);
+		}));
+		const supportedTypes = Object.values(DBColumnTypes);
+		const store = { tables: serialized.filter((it) => {
+			if (it.primaryKey.length === 0) {
+				Console.error(`table ${it.tableName} skipped, reason: missing primary key`);
+				return false;
+			}
+			const notSupported = it.columns.find((it) => !supportedTypes.includes(it.type));
+			if (notSupported) {
+				Console.error(`table ${it.tableName} skipped,  reason: ${it.tableName}.${notSupported.columnName} column type "${notSupported.type}" is Not Supported`);
+				return false;
+			}
+			return true;
+		}) };
+		writeYmlFile(config().migration.dir, "initialSchema.yml", store);
+	} catch (e) {
+		Console.error(e.message);
+		throw e;
+	} finally {
+		await con.release();
+	}
+};
+//#endregion
+//#region src/cli/commands/getCurrentStore.ts
+async function getCurrentStore() {
+	await compileMigrationFiles();
+	const files = getMigrationFileNames();
+	return (await createCurrentMigrationDataStore(files.find((it) => it === config().migration.target) || files[files.length - 1])).serialize();
+}
+//#endregion
+//#region src/cli/commands/erDiagram.ts
+const writeDiagram = async () => {
+	try {
+		const store = new DataStoreHandler(await getCurrentStore());
+		const result = `erDiagram
+${store.tables.map((it) => processTable(store, it)).join("\n")}
+`;
+		fs.writeFileSync(path.join(config().migration.out, Directory.paths.GENERATED, "er-diagram.mermaid"), result);
+	} catch (e) {
+		Console.error(e.message);
+		throw e;
+	}
+};
+function getRefType(parent, rel) {
+	const left = parent.isNullable() ? "|o" : "||";
+	const getRight = () => {
+		switch (rel) {
+			case "One": return "||";
+			case "Many": return "o{";
+			case "OneOrZero": return "|o";
+		}
+	};
+	return `${left} -- ${getRight()}`;
+}
+function processTable(store, table) {
+	const rel = table.columns.filter((it) => it.isReference()).map((it) => {
+		const rel = it;
+		const ref = rel.data.reference;
+		const parent = store.table(ref.parentTable).column(ref.parentColumn);
+		return `${ref.parentTable} ${getRefType(parent, ref.relation)} ${table.tableName} : ${ref.relationName ?? `"${rel.data.reference.parentTable}__${rel.table.tableName}"`}`;
+	});
+	return `${table.tableName} {
+${table.columns.map((it) => `  ${it.columnName()} ${it.dataType()}`).join("\n")}
+}
+${rel.join("\n")}
+`;
+}
+//#endregion
+//#region src/cli/commands/generate.ts
+const generate = async () => {
+	try {
+		await compileMigrationFiles();
+		const files = getMigrationFileNames();
+		const targetFile = files.find((it) => it === config().migration.target) || files[files.length - 1];
+		const store = await getCurrentStore();
+		const storeHandler = new DataStoreHandler(store);
+		writeCurrentSchema(store);
+		await new CodeGen_v2(storeHandler).generate();
+		Console.success(`code generated. DIR: ${config().migration.out}\nmigration target: ${targetFile}`);
+	} catch (e) {
+		Console.error(e.message);
+		throw e;
+	}
+};
+//#endregion
+//#region src/cli/commands/init.ts
+const init = () => {
+	if (fs$1.existsSync("./sasat.yml")) {
+		Console.error("sasat.yml already exist");
+		return;
+	}
+	writeYmlFile("./", "sasat.yml", defaultConf);
+	Console.success("sasat.yml created");
+};
+//#endregion
+//#region src/cli/commands/migrationBuild.ts
+const migrationBuild = async () => {
+	Console.log("--migration build started--");
+	await compileMigrationFiles();
+	Console.success("Done!");
+};
+//#endregion
+//#region src/cli/index.ts
+const index = cac();
+try {
+	index.usage("yarn sasat <command> [options]\n").command("migrate", "execute migration").option("-g, --generateFiles", "migrate with generate files").option("-d, --dry", "dry run").option("-s, --silent", "do not print logs").option("-b, --skipBuild", "skip compile migration files").action(async (options) => {
+		const client = getDbClient();
+		await migrate(client, options).catch((e) => {
+			console.error(e);
+			process.exit(1);
+		});
+		await client.release();
+	});
+	index.command("migration:build", "compile migration files").action(migrationBuild);
+	index.command("generate", "generate files").action(generate);
+	index.command("generate:er", "generate mermaid er diagram").action(writeDiagram);
+	index.command("migration:create [name]", "generate new migration file").action(createMigration);
+	index.command("dump-db", "dump database schema").action(dumpDB);
+	index.command("init").action(init);
+	index.parse();
+	if (!index.matchedCommand) index.outputHelp();
+} catch (e) {
+	console.error(e);
+	process.exit(1);
+}
+//#endregion
+export {};