sasat 0.22.4 → 0.22.6

package/dist/migration/index.mjs

@@ -0,0 +1,61 @@
+import { t as Conditions } from "../makeCondition-3MdYUm5k.mjs";
+//#region src/migration/makeMutaion.ts
+const formatSubscription = (subscription) => {
+	if (subscription === void 0 || subscription === false) return {
+		enabled: false,
+		subscriptionFilter: []
+	};
+	if (subscription === true) return {
+		enabled: true,
+		subscriptionFilter: []
+	};
+	return {
+		enabled: subscription.enabled,
+		subscriptionFilter: subscription.subscriptionFilter || []
+	};
+};
+const formatOptions = (type, option) => ({
+	type,
+	noReFetch: option?.noRefetch || false,
+	middlewares: option?.middlewares || [],
+	contextFields: option?.contextFields || [],
+	subscription: formatSubscription(option?.subscription)
+});
+const Mutations = {
+	create: (options) => formatOptions("create", options),
+	update: (options) => formatOptions("update", options),
+	delete: (options) => formatOptions("delete", options)
+};
+//#endregion
+//#region src/migration/makeQuery.ts
+const single = (name, options) => ({
+	type: "single",
+	name,
+	conditions: options?.conditions || [],
+	middlewares: options?.middlewares || []
+});
+const listAll = (name, options) => ({
+	type: "list-all",
+	name,
+	conditions: options?.conditions || [],
+	middlewares: options?.middlewares || []
+});
+const paging = (name, options) => ({
+	type: "list-paging",
+	name,
+	conditions: options?.conditions || [],
+	middlewares: options?.middlewares || []
+});
+const primary = (middlewares = []) => ({
+	type: "primary",
+	conditions: [],
+	middlewares
+});
+const Queries = {
+	single,
+	listAll,
+	paging,
+	primary
+};
+//#endregion
+export { Conditions, Mutations, Queries };

package/dist/testing/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_migrate = require("../migrate-BDE07ocG.cjs");
+exports.migrate = require_migrate.migrate;

package/dist/testing/index.d.cts

@@ -0,0 +1,12 @@
+import { n as DBClient } from "../dbClient-Bnk1JKBU.cjs";
+
+//#region src/cli/commands/migrate.d.ts
+type MigrateCommandOption = {
+  generateFiles: boolean;
+  silent: boolean;
+  dry: boolean;
+  skipBuild: boolean;
+};
+declare const migrate: (client: DBClient, options: MigrateCommandOption) => Promise<void>;
+//#endregion
+export { migrate };

package/dist/testing/index.d.mts

@@ -0,0 +1,12 @@
+import { n as DBClient } from "../dbClient-2mFJTQw7.mjs";
+
+//#region src/cli/commands/migrate.d.ts
+type MigrateCommandOption = {
+  generateFiles: boolean;
+  silent: boolean;
+  dry: boolean;
+  skipBuild: boolean;
+};
+declare const migrate: (client: DBClient, options: MigrateCommandOption) => Promise<void>;
+//#endregion
+export { migrate };

package/dist/testing/index.mjs

@@ -0,0 +1,2 @@
+import { t as migrate } from "../migrate-DnqBdQ6r.mjs";
+export { migrate };

package/dist/util-C5Jevn5B.cjs

@@ -0,0 +1,377 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_fs_promises = require("node:fs/promises");
+let js_yaml = require("js-yaml");
+js_yaml = __toESM(js_yaml, 1);
+let mysql2_promise = require("mysql2/promise");
+let sqlstring = require("sqlstring");
+sqlstring = __toESM(sqlstring, 1);
+//#region src/util/assignDeep.ts
+const assignDeep = (base, ...objects) => {
+	const assign = (target, key, value) => {
+		if (key === "__proto__" || key === "constructor") return;
+		if (Array.isArray(target[key]) && Array.isArray(value)) target[key] = [...target[key], ...value];
+		else if (typeof target[key] === "object" && typeof value === "object") assignDeep(target[key], value);
+		else target[key] = value;
+	};
+	objects.forEach((obj) => {
+		if (typeof obj === "object") Object.entries(obj).forEach(([key, value]) => {
+			assign(base, key, value);
+		});
+	});
+	return base;
+};
+//#endregion
+//#region src/util/fsUtil.ts
+const readYmlFile = (filepath) => js_yaml.default.load((0, node_fs.readFileSync)(filepath, "utf8"));
+const mkDirIfNotExist = (path) => {
+	if (!(0, node_fs.existsSync)(path)) (0, node_fs.mkdirSync)(path, { recursive: true });
+};
+const writeFileIfNotExist = (path, data) => {
+	if ((0, node_fs.existsSync)(path)) return Promise.resolve();
+	return (0, node_fs_promises.writeFile)(path, data);
+};
+const writeYmlFile = (path, fileName, obj) => {
+	mkDirIfNotExist(path);
+	(0, node_fs.writeFileSync)((0, node_path.join)(path, fileName), js_yaml.default.dump(obj, {
+		skipInvalid: true,
+		noRefs: true,
+		sortKeys: (a, b) => {
+			if (b === "tableName") return 1;
+			if (a === "tableName") return -1;
+			if (a > b) return 1;
+			if (a < b) return -1;
+			return 0;
+		}
+	}));
+};
+const readInitialSchema = () => {
+	return readYmlFile((0, node_path.join)(config().migration.dir, "initialSchema.yml"));
+};
+const writeCurrentSchema = (schema) => {
+	writeYmlFile(config().migration.dir, "currentSchema.yml", schema);
+};
+//#endregion
+//#region src/config/loader.ts
+var SasatConfigLoader = class SasatConfigLoader {
+	static loadConfig() {
+		const filepath = node_path.default.join(process.cwd(), "sasat.yml");
+		if (!(0, node_fs.existsSync)(filepath)) return defaultConf;
+		return readYmlFile(filepath);
+	}
+	constructor() {
+		const conf = this.readValue({
+			...defaultConf,
+			...SasatConfigLoader.loadConfig()
+		});
+		this.conf = { ...conf };
+	}
+	getConfig() {
+		return this.conf;
+	}
+	readValue(value) {
+		if (!value) return value;
+		if (Array.isArray(value)) return value.map((it) => this.readValue(it));
+		if (typeof value === "string" && value.startsWith("$")) return process.env[value.slice(1)];
+		if (typeof value === "object") {
+			for (const key in value) if (Object.hasOwn(value, key)) value[key] = this.readValue(value[key]);
+			return value;
+		}
+		return value;
+	}
+};
+const defaultConf = {
+	db: {
+		host: "127.0.0.1",
+		port: 3306,
+		user: "root",
+		database: "sasat",
+		password: ""
+	},
+	migration: {
+		table: "__migrate__",
+		dir: "migrations",
+		out: "sasat"
+	},
+	generator: {
+		addJsExtToImportStatement: false,
+		gql: { subscription: true }
+	}
+};
+let conf;
+const config = () => {
+	if (conf === void 0) conf = new SasatConfigLoader().getConfig();
+	return conf;
+};
+function setConfig(update) {
+	conf = assignDeep(config(), update);
+	return conf;
+}
+//#endregion
+//#region src/runtime/sql/sqlString.ts
+const { escape, escapeId } = sqlstring.default;
+const SqlString = {
+	escape: (value) => escape(value, true),
+	escapeId: (name) => escapeId(name)
+};
+//#endregion
+//#region src/db/formatQuery.ts
+const formatQuery = (str, ...params) => {
+	let ret = str[0];
+	for (let i = 0; i < params.length; i++) {
+		if (typeof params[i] === "function") ret += params[i]();
+		else if (Array.isArray(params[i])) ret += params[i].map((it) => SqlString.escape(it)).join(", ");
+		else ret += SqlString.escape(params[i]);
+		ret += str[i + 1];
+	}
+	return ret;
+};
+//#endregion
+//#region src/db/connectors/dbClient.ts
+const noop = () => {};
+var SQLClient = class {
+	constructor() {
+		this.logger = noop;
+	}
+	rawQuery(sql) {
+		this.logger(sql);
+		return this.execSql(sql);
+	}
+	rawCommand(sql) {
+		this.logger(sql);
+		return this.execSql(sql);
+	}
+	query(templateString, ...params) {
+		return this.rawQuery(formatQuery(templateString, ...params));
+	}
+	command(templateString, ...params) {
+		return this.rawCommand(formatQuery(templateString, ...params));
+	}
+};
+var SQLTransaction = class extends SQLClient {};
+var DBClient = class extends SQLClient {
+	constructor(logger = noop) {
+		super();
+		this._released = false;
+		this.logger = logger;
+	}
+	isReleased() {
+		return this._released;
+	}
+};
+//#endregion
+//#region src/db/connectors/mysql/transaction.ts
+var MySqlTransaction = class extends SQLTransaction {
+	constructor(connection) {
+		super();
+		this.connection = connection;
+	}
+	async commit() {
+		const result = await this.connection.commit();
+		await this.connection.end();
+		return result;
+	}
+	async rollback() {
+		await this.connection.rollback();
+		await this.connection.end();
+	}
+	async execSql(sql) {
+		return (await this.connection.query(sql))[0];
+	}
+};
+//#endregion
+//#region src/db/connectors/mysql/poolClient.ts
+var MysqlPoolClient = class extends DBClient {
+	constructor(poolOption, logger) {
+		super(logger);
+		this.poolOption = poolOption;
+		this.pool = (0, mysql2_promise.createPool)({
+			dateStrings: true,
+			...poolOption
+		});
+		this.release = this.release.bind(this);
+	}
+	async transaction() {
+		const connection = await (0, mysql2_promise.createConnection)({
+			...config().db,
+			dateStrings: true,
+			...this.poolOption
+		});
+		await connection.beginTransaction();
+		return new MySqlTransaction(connection);
+	}
+	async release() {
+		await this.pool.end();
+		this._released = true;
+	}
+	async execSql(sql) {
+		return (await this.pool.query(sql))[0];
+	}
+};
+//#endregion
+//#region src/db/getDbClient.ts
+let client;
+const getDbClient = (option, logger) => {
+	if (client && !client.isReleased()) return client;
+	client = new MysqlPoolClient({
+		...config().db,
+		...option
+	}, logger);
+	return client;
+};
+//#endregion
+//#region src/error.ts
+var SasatError = class extends Error {
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = "SasatError";
+	}
+};
+//#endregion
+//#region src/runtime/util.ts
+const pick = (target, keys) => Object.fromEntries(keys.map((key) => [key, target[key]]));
+const unique = (array) => {
+	const result = [];
+	for (let i = 0, l = array.length; i < l; i += 1) if (!result.includes(array[i])) result.push(array[i]);
+	return result;
+};
+const nonNullable = (value) => value != null;
+//#endregion
+Object.defineProperty(exports, "DBClient", {
+	enumerable: true,
+	get: function() {
+		return DBClient;
+	}
+});
+Object.defineProperty(exports, "MySqlTransaction", {
+	enumerable: true,
+	get: function() {
+		return MySqlTransaction;
+	}
+});
+Object.defineProperty(exports, "SasatError", {
+	enumerable: true,
+	get: function() {
+		return SasatError;
+	}
+});
+Object.defineProperty(exports, "SqlString", {
+	enumerable: true,
+	get: function() {
+		return SqlString;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "assignDeep", {
+	enumerable: true,
+	get: function() {
+		return assignDeep;
+	}
+});
+Object.defineProperty(exports, "config", {
+	enumerable: true,
+	get: function() {
+		return config;
+	}
+});
+Object.defineProperty(exports, "defaultConf", {
+	enumerable: true,
+	get: function() {
+		return defaultConf;
+	}
+});
+Object.defineProperty(exports, "formatQuery", {
+	enumerable: true,
+	get: function() {
+		return formatQuery;
+	}
+});
+Object.defineProperty(exports, "getDbClient", {
+	enumerable: true,
+	get: function() {
+		return getDbClient;
+	}
+});
+Object.defineProperty(exports, "mkDirIfNotExist", {
+	enumerable: true,
+	get: function() {
+		return mkDirIfNotExist;
+	}
+});
+Object.defineProperty(exports, "nonNullable", {
+	enumerable: true,
+	get: function() {
+		return nonNullable;
+	}
+});
+Object.defineProperty(exports, "pick", {
+	enumerable: true,
+	get: function() {
+		return pick;
+	}
+});
+Object.defineProperty(exports, "readInitialSchema", {
+	enumerable: true,
+	get: function() {
+		return readInitialSchema;
+	}
+});
+Object.defineProperty(exports, "setConfig", {
+	enumerable: true,
+	get: function() {
+		return setConfig;
+	}
+});
+Object.defineProperty(exports, "unique", {
+	enumerable: true,
+	get: function() {
+		return unique;
+	}
+});
+Object.defineProperty(exports, "writeCurrentSchema", {
+	enumerable: true,
+	get: function() {
+		return writeCurrentSchema;
+	}
+});
+Object.defineProperty(exports, "writeFileIfNotExist", {
+	enumerable: true,
+	get: function() {
+		return writeFileIfNotExist;
+	}
+});
+Object.defineProperty(exports, "writeYmlFile", {
+	enumerable: true,
+	get: function() {
+		return writeYmlFile;
+	}
+});

package/dist/util-Dkw5bD7a.mjs

@@ -0,0 +1,239 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path, { join } from "node:path";
+import { writeFile } from "node:fs/promises";
+import yaml from "js-yaml";
+import { createConnection, createPool } from "mysql2/promise";
+import pkg from "sqlstring";
+//#region src/util/assignDeep.ts
+const assignDeep = (base, ...objects) => {
+	const assign = (target, key, value) => {
+		if (key === "__proto__" || key === "constructor") return;
+		if (Array.isArray(target[key]) && Array.isArray(value)) target[key] = [...target[key], ...value];
+		else if (typeof target[key] === "object" && typeof value === "object") assignDeep(target[key], value);
+		else target[key] = value;
+	};
+	objects.forEach((obj) => {
+		if (typeof obj === "object") Object.entries(obj).forEach(([key, value]) => {
+			assign(base, key, value);
+		});
+	});
+	return base;
+};
+//#endregion
+//#region src/util/fsUtil.ts
+const readYmlFile = (filepath) => yaml.load(readFileSync(filepath, "utf8"));
+const mkDirIfNotExist = (path) => {
+	if (!existsSync(path)) mkdirSync(path, { recursive: true });
+};
+const writeFileIfNotExist = (path, data) => {
+	if (existsSync(path)) return Promise.resolve();
+	return writeFile(path, data);
+};
+const writeYmlFile = (path, fileName, obj) => {
+	mkDirIfNotExist(path);
+	writeFileSync(join(path, fileName), yaml.dump(obj, {
+		skipInvalid: true,
+		noRefs: true,
+		sortKeys: (a, b) => {
+			if (b === "tableName") return 1;
+			if (a === "tableName") return -1;
+			if (a > b) return 1;
+			if (a < b) return -1;
+			return 0;
+		}
+	}));
+};
+const readInitialSchema = () => {
+	return readYmlFile(join(config().migration.dir, "initialSchema.yml"));
+};
+const writeCurrentSchema = (schema) => {
+	writeYmlFile(config().migration.dir, "currentSchema.yml", schema);
+};
+//#endregion
+//#region src/config/loader.ts
+var SasatConfigLoader = class SasatConfigLoader {
+	static loadConfig() {
+		const filepath = path.join(process.cwd(), "sasat.yml");
+		if (!existsSync(filepath)) return defaultConf;
+		return readYmlFile(filepath);
+	}
+	constructor() {
+		const conf = this.readValue({
+			...defaultConf,
+			...SasatConfigLoader.loadConfig()
+		});
+		this.conf = { ...conf };
+	}
+	getConfig() {
+		return this.conf;
+	}
+	readValue(value) {
+		if (!value) return value;
+		if (Array.isArray(value)) return value.map((it) => this.readValue(it));
+		if (typeof value === "string" && value.startsWith("$")) return process.env[value.slice(1)];
+		if (typeof value === "object") {
+			for (const key in value) if (Object.hasOwn(value, key)) value[key] = this.readValue(value[key]);
+			return value;
+		}
+		return value;
+	}
+};
+const defaultConf = {
+	db: {
+		host: "127.0.0.1",
+		port: 3306,
+		user: "root",
+		database: "sasat",
+		password: ""
+	},
+	migration: {
+		table: "__migrate__",
+		dir: "migrations",
+		out: "sasat"
+	},
+	generator: {
+		addJsExtToImportStatement: false,
+		gql: { subscription: true }
+	}
+};
+let conf;
+const config = () => {
+	if (conf === void 0) conf = new SasatConfigLoader().getConfig();
+	return conf;
+};
+function setConfig(update) {
+	conf = assignDeep(config(), update);
+	return conf;
+}
+//#endregion
+//#region src/runtime/sql/sqlString.ts
+const { escape, escapeId } = pkg;
+const SqlString = {
+	escape: (value) => escape(value, true),
+	escapeId: (name) => escapeId(name)
+};
+//#endregion
+//#region src/db/formatQuery.ts
+const formatQuery = (str, ...params) => {
+	let ret = str[0];
+	for (let i = 0; i < params.length; i++) {
+		if (typeof params[i] === "function") ret += params[i]();
+		else if (Array.isArray(params[i])) ret += params[i].map((it) => SqlString.escape(it)).join(", ");
+		else ret += SqlString.escape(params[i]);
+		ret += str[i + 1];
+	}
+	return ret;
+};
+//#endregion
+//#region src/db/connectors/dbClient.ts
+const noop = () => {};
+var SQLClient = class {
+	constructor() {
+		this.logger = noop;
+	}
+	rawQuery(sql) {
+		this.logger(sql);
+		return this.execSql(sql);
+	}
+	rawCommand(sql) {
+		this.logger(sql);
+		return this.execSql(sql);
+	}
+	query(templateString, ...params) {
+		return this.rawQuery(formatQuery(templateString, ...params));
+	}
+	command(templateString, ...params) {
+		return this.rawCommand(formatQuery(templateString, ...params));
+	}
+};
+var SQLTransaction = class extends SQLClient {};
+var DBClient = class extends SQLClient {
+	constructor(logger = noop) {
+		super();
+		this._released = false;
+		this.logger = logger;
+	}
+	isReleased() {
+		return this._released;
+	}
+};
+//#endregion
+//#region src/db/connectors/mysql/transaction.ts
+var MySqlTransaction = class extends SQLTransaction {
+	constructor(connection) {
+		super();
+		this.connection = connection;
+	}
+	async commit() {
+		const result = await this.connection.commit();
+		await this.connection.end();
+		return result;
+	}
+	async rollback() {
+		await this.connection.rollback();
+		await this.connection.end();
+	}
+	async execSql(sql) {
+		return (await this.connection.query(sql))[0];
+	}
+};
+//#endregion
+//#region src/db/connectors/mysql/poolClient.ts
+var MysqlPoolClient = class extends DBClient {
+	constructor(poolOption, logger) {
+		super(logger);
+		this.poolOption = poolOption;
+		this.pool = createPool({
+			dateStrings: true,
+			...poolOption
+		});
+		this.release = this.release.bind(this);
+	}
+	async transaction() {
+		const connection = await createConnection({
+			...config().db,
+			dateStrings: true,
+			...this.poolOption
+		});
+		await connection.beginTransaction();
+		return new MySqlTransaction(connection);
+	}
+	async release() {
+		await this.pool.end();
+		this._released = true;
+	}
+	async execSql(sql) {
+		return (await this.pool.query(sql))[0];
+	}
+};
+//#endregion
+//#region src/db/getDbClient.ts
+let client;
+const getDbClient = (option, logger) => {
+	if (client && !client.isReleased()) return client;
+	client = new MysqlPoolClient({
+		...config().db,
+		...option
+	}, logger);
+	return client;
+};
+//#endregion
+//#region src/error.ts
+var SasatError = class extends Error {
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = "SasatError";
+	}
+};
+//#endregion
+//#region src/runtime/util.ts
+const pick = (target, keys) => Object.fromEntries(keys.map((key) => [key, target[key]]));
+const unique = (array) => {
+	const result = [];
+	for (let i = 0, l = array.length; i < l; i += 1) if (!result.includes(array[i])) result.push(array[i]);
+	return result;
+};
+const nonNullable = (value) => value != null;
+//#endregion
+export { writeYmlFile as _, getDbClient as a, formatQuery as c, defaultConf as d, setConfig as f, writeFileIfNotExist as g, writeCurrentSchema as h, SasatError as i, SqlString as l, readInitialSchema as m, pick as n, MySqlTransaction as o, mkDirIfNotExist as p, unique as r, DBClient as s, nonNullable as t, config as u, assignDeep as v };