@noormdev/sdk 1.4.1 → 1.5.0

package/dist/{chunk-G4B7EHL7.js → chunk-M7Q44VFJ.js}

@@ -1,5 +1,6 @@
 import { createRequire } from 'module';
-import { attemptSync, observer, attempt } from './chunk-LY2F7ZFI.js';
+import { observer } from './chunk-6LG4ENOJ.js';
+import { attemptSync, attempt } from './chunk-TXDGFA44.js';
 import { dist_default } from './chunk-TBRUDUBQ.js';
 import { readFile as readFile$1, readdir, stat } from 'fs/promises';
 import * as fs from 'fs';
@@ -2505,7 +2506,7 @@ function createIncludeHelper(templateDir, projectRoot, options) {
       throw new Error(`Include path escapes project root: ${includePath}`);
     }
     if (resolved.endsWith(".tmpl")) {
-      const { processFile: processFile2 } = await import('./engine-MZQ364EH.js');
+      const { processFile: processFile2 } = await import('./engine-P74UTJQO.js');
       const result = await processFile2(resolved, options);
       return result.sql;
     }
@@ -2587,5 +2588,5 @@ voca/es/index.js:
 */
 
 export { DT_EXTENSIONS, DtReader, ENCODED_TYPES, FORMAT_VERSION, encryptWithPassphrase, es_default, eta, isTemplate, processFile, processFiles, renderTemplate };
-//# sourceMappingURL=chunk-G4B7EHL7.js.map
-//# sourceMappingURL=chunk-G4B7EHL7.js.map
+//# sourceMappingURL=chunk-M7Q44VFJ.js.map
+//# sourceMappingURL=chunk-M7Q44VFJ.js.map

package/dist/chunk-OXTXFKWJ.js

@@ -0,0 +1,188 @@
+import { createRequire } from 'module';
+import { attemptSync } from './chunk-TXDGFA44.js';
+import { DEFAULT_PORTS, connectTimeoutFor } from './chunk-WE2JLJMT.js';
+import { existsSync, constants, accessSync } from 'fs';
+import { resolve, dirname } from 'path';
+
+createRequire(import.meta.url);
+var DatabaseConnectionError = class extends Error {
+  constructor(message, serverCode, serverMessage, options) {
+    super(message, options);
+    this.serverCode = serverCode;
+    this.serverMessage = serverMessage;
+  }
+  name = "DatabaseConnectionError";
+};
+var noPassword = ({ user }) => `No password was supplied for user '${user}', and the server requires one.`;
+var timedOut = ({ where, config }) => `${where} did not answer within ${connectTimeoutFor(config)}ms. Check the host and port, and that no firewall is dropping the connection.`;
+var SERVER_FULL = "The server has no free connections (max_connections reached). Try again later.";
+var TRANSPORT_REASONS = [
+  [["ECONNREFUSED"], ({ where }) => `Connection refused at ${where}: nothing is listening there. Check the host and port, and that the server is running.`],
+  [["ENOTFOUND"], ({ host }) => `Host '${host}' could not be found. Check the host name.`],
+  [["EAI_AGAIN"], ({ host }) => `Host '${host}' could not be looked up: DNS did not answer. Check the network connection.`],
+  [["ETIMEDOUT", "ETIMEOUT"], timedOut],
+  [["EHOSTUNREACH", "ENETUNREACH"], ({ host }) => `${host} is unreachable from this machine: there is no network route to it.`],
+  [["ECONNRESET"], ({ where }) => `${where} closed the connection during the handshake. Check that the port belongs to this database server and that the ssl setting matches what it expects.`]
+];
+var TLS_CERTIFICATE_CODES = /* @__PURE__ */ new Set([
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "CERT_HAS_EXPIRED",
+  "CERT_NOT_YET_VALID",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+var MSSQL_REASONS = [
+  [4060, ({ database, where }) => `Cannot open database '${database}' on ${where}: it does not exist or this login has no access to it.`],
+  [40615, () => "The server's firewall does not allow this machine's IP address. Add it to the server's firewall rules."],
+  [18470, ({ user }) => `Login '${user}' is disabled. An administrator can enable it with ALTER LOGIN ... ENABLE.`],
+  [18486, ({ user }) => `Login '${user}' is locked out after too many failed attempts.`],
+  [18487, ({ user }) => `The password for login '${user}' has expired. Change it with a SQL Server client, then update this connection.`],
+  [18488, ({ user }) => `The password for login '${user}' must be changed before it can log in. Change it with a SQL Server client, then update this connection.`],
+  [18456, ({ user }) => `Login failed for user '${user}'. SQL Server does not tell clients why; the usual causes are a wrong password, an unknown login, a login denied CONNECT SQL, or a server that only accepts Windows authentication. The server's error log names the cause.`]
+];
+var POSTGRES_REASONS = {
+  "28P01": ({ user }) => `Password authentication failed for user '${user}'. PostgreSQL does not tell clients why; the usual causes are a wrong password, an unknown role, or an expired password (VALID UNTIL). The server log names the cause.`,
+  "28000": ({ user, database, message }) => {
+    if (message.includes("is not permitted to log in")) return `Role '${user}' is not allowed to log in (NOLOGIN).`;
+    if (message.includes("pg_hba.conf")) {
+      return `The server's pg_hba.conf has no rule that lets user '${user}' connect to '${database}' from this machine.`;
+    }
+    return void 0;
+  },
+  "3D000": ({ database, where }) => `Database '${database}' does not exist on ${where}.`,
+  "42501": ({ user, database, message }) => message.startsWith("permission denied for database") ? `Role '${user}' may not connect to database '${database}': it lacks the CONNECT privilege.` : void 0,
+  "53300": ({ user, message }) => message.includes("for role") ? `Role '${user}' has used up its connection limit (CONNECTION LIMIT).` : SERVER_FULL,
+  "57P03": () => "The server is starting up or shutting down. Try again in a moment."
+};
+var POSTGRES_CLIENT_REASONS = [
+  // pg raises this itself when the server asks for a SCRAM password and the
+  // config has none.
+  ["client password must be a string", noPassword],
+  ["The server does not support SSL connections", () => "The server does not accept TLS connections. Turn ssl off for this connection."],
+  ["Connection terminated due to connection timeout", timedOut]
+];
+var MYSQL_REASONS = {
+  ER_ACCESS_DENIED_ERROR: (failure) => failure.message.includes("(using password: NO)") ? noPassword(failure) : `Access denied for user '${failure.user}'. MySQL does not tell clients why; the usual causes are a wrong password, an unknown user, no account for this machine's host, or an account that requires TLS (REQUIRE SSL).`,
+  ER_DBACCESS_DENIED_ERROR: ({ user, database }) => `User '${user}' has no privileges on database '${database}'.`,
+  ER_BAD_DB_ERROR: ({ database, where }) => `Database '${database}' does not exist on ${where}.`,
+  ER_HOST_NOT_PRIVILEGED: () => "The server accepts no account from this machine's host.",
+  ER_ACCOUNT_HAS_BEEN_LOCKED: ({ user }) => `Account '${user}' is locked. An administrator can unlock it with ALTER USER ... ACCOUNT UNLOCK.`,
+  ER_MUST_CHANGE_PASSWORD_LOGIN: ({ user }) => `The password for '${user}' has expired. Change it with a MySQL client, then update this connection.`,
+  ER_CON_COUNT_ERROR: () => SERVER_FULL,
+  ER_USER_LIMIT_REACHED: ({ user }) => `User '${user}' has used up its connection limit (MAX_USER_CONNECTIONS).`,
+  ER_HOST_IS_BLOCKED: () => "The server blocked this machine after too many connection errors. An administrator can clear its host cache.",
+  ER_SECURE_TRANSPORT_REQUIRED: () => "The server only accepts TLS connections. Turn ssl on for this connection."
+};
+function explainConnectionError(err, config) {
+  if (err instanceof DatabaseConnectionError) return err;
+  const codes = errorCodes(err);
+  const failure = describeFailure(err, config);
+  const reason = explainTransport(codes, failure) ?? explainServer(codes, failure);
+  const serverMessage = serverMessages(err).join(" | ");
+  if (!reason && codes.length === 0) return err;
+  return new DatabaseConnectionError(
+    reason ?? (err.message || serverMessage),
+    codes.join(", ") || void 0,
+    serverMessage,
+    { cause: err }
+  );
+}
+function explainMssqlLoginFailure(serverErrors, err, config) {
+  if (serverErrors.length === 0) return err;
+  const failure = describeFailure(err, config);
+  const match = MSSQL_REASONS.find(([number]) => serverErrors.some((e) => e.number === number));
+  return new DatabaseConnectionError(
+    match?.[1](failure) ?? err.message,
+    serverErrors.map((e) => e.number).join(", "),
+    serverErrors.map((e) => e.message).join(" | "),
+    { cause: err }
+  );
+}
+function describeFailure(err, config) {
+  const host = config.host ?? "localhost";
+  return {
+    user: config.user ?? "",
+    database: config.database,
+    host,
+    where: `${host}:${config.port ?? DEFAULT_PORTS[config.dialect]}`,
+    config,
+    message: err.message
+  };
+}
+function walk(err, visit, seen = /* @__PURE__ */ new Set()) {
+  if (typeof err !== "object" || err === null || seen.has(err)) return;
+  const inner = Reflect.get(err, "errors");
+  seen.add(err);
+  visit(err);
+  walk(Reflect.get(err, "cause"), visit, seen);
+  if (Array.isArray(inner)) {
+    for (const each of inner) walk(each, visit, seen);
+  }
+}
+function errorCodes(err) {
+  const codes = /* @__PURE__ */ new Set();
+  walk(err, (error) => {
+    const code = Reflect.get(error, "code");
+    if (typeof code === "string") codes.add(code);
+  });
+  return [...codes];
+}
+function serverMessages(err) {
+  const messages = /* @__PURE__ */ new Set();
+  walk(err, (error) => {
+    const message = Reflect.get(error, "message");
+    if (typeof message === "string" && message) messages.add(message);
+  });
+  return [...messages];
+}
+function explainTransport(codes, failure) {
+  const transport = TRANSPORT_REASONS.find(([matches]) => matches.some((code) => codes.includes(code)));
+  if (transport) return transport[1](failure);
+  const certificateCode = codes.find((code) => TLS_CERTIFICATE_CODES.has(code));
+  if (!certificateCode) return void 0;
+  const withoutValidation = failure.config.dialect === "mssql" ? "turn ssl off to keep encryption without validating the certificate" : "turn ssl off, which also turns off encryption";
+  return `The server's TLS certificate was rejected (${certificateCode}). Trust the authority that issued it on this machine, or ${withoutValidation}.`;
+}
+function explainServer(codes, failure) {
+  const code = codes[0] ?? "";
+  switch (failure.config.dialect) {
+    case "postgres": {
+      const client = POSTGRES_CLIENT_REASONS.find(([text]) => failure.message.includes(text));
+      return POSTGRES_REASONS[code]?.(failure) ?? client?.[1](failure);
+    }
+    case "mysql":
+      return MYSQL_REASONS[code]?.(failure);
+    case "sqlite":
+      return explainSqlite(code, failure);
+    default:
+      return void 0;
+  }
+}
+function explainSqlite(code, failure) {
+  const file = resolve(failure.config.filename ?? failure.database);
+  const dir = dirname(file);
+  if (code === "SQLITE_NOTADB") {
+    return `'${file}' is not a SQLite database, or it is encrypted.`;
+  }
+  if (code !== "SQLITE_CANTOPEN") return void 0;
+  if (!existsSync(dir)) {
+    return `Cannot open SQLite database '${file}': directory '${dir}' is missing.`;
+  }
+  if (existsSync(file) && !canAccess(file, constants.R_OK | constants.W_OK)) {
+    return `Cannot open SQLite database '${file}': this process lacks read or write permission on the file.`;
+  }
+  if (!existsSync(file) && !canAccess(dir, constants.W_OK)) {
+    return `Cannot create SQLite database '${file}': this process lacks write permission on '${dir}'.`;
+  }
+  return void 0;
+}
+function canAccess(path, mode) {
+  const [, err] = attemptSync(() => accessSync(path, mode));
+  return !err;
+}
+
+export { DatabaseConnectionError, explainConnectionError, explainMssqlLoginFailure };
+//# sourceMappingURL=chunk-OXTXFKWJ.js.map
+//# sourceMappingURL=chunk-OXTXFKWJ.js.map