feat(auth): implement user authentication system

backend/node_modules/sql-escaper/lib/index.mjs

@@ -0,0 +1,305 @@
+import { Buffer } from "node:buffer";
+const regex = {
+  backtick: /`/g,
+  dot: /\./g,
+  timezone: /([+\-\s])(\d\d):?(\d\d)?/,
+  escapeChars: /[\0\b\t\n\r\x1a"'\\]/g
+};
+const CHARS_ESCAPE_MAP = {
+  "\0": "\\0",
+  "\b": "\\b",
+  "	": "\\t",
+  "\n": "\\n",
+  "\r": "\\r",
+  "": "\\Z",
+  '"': '\\"',
+  "'": "\\'",
+  "\\": "\\\\"
+};
+const charCode = {
+  singleQuote: 39,
+  backtick: 96,
+  backslash: 92,
+  dash: 45,
+  slash: 47,
+  asterisk: 42,
+  questionMark: 63,
+  newline: 10,
+  space: 32,
+  tab: 9,
+  carriageReturn: 13
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isWordChar = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95;
+const isWhitespace = (code) => code === charCode.space || code === charCode.tab || code === charCode.newline || code === charCode.carriageReturn;
+const hasOnlyWhitespaceBetween = (sql, start, end) => {
+  if (start >= end) return true;
+  for (let i = start; i < end; i++) {
+    const code = sql.charCodeAt(i);
+    if (code !== charCode.space && code !== charCode.tab && code !== charCode.newline && code !== charCode.carriageReturn)
+      return false;
+  }
+  return true;
+};
+const toLower = (code) => code | 32;
+const matchesWord = (sql, position, word, length) => {
+  for (let offset = 0; offset < word.length; offset++)
+    if (toLower(sql.charCodeAt(position + offset)) !== word.charCodeAt(offset))
+      return false;
+  return (position === 0 || !isWordChar(sql.charCodeAt(position - 1))) && (position + word.length >= length || !isWordChar(sql.charCodeAt(position + word.length)));
+};
+const skipSqlContext = (sql, position) => {
+  const currentChar = sql.charCodeAt(position);
+  const nextChar = sql.charCodeAt(position + 1);
+  if (currentChar === charCode.singleQuote) {
+    for (let cursor = position + 1; cursor < sql.length; cursor++) {
+      if (sql.charCodeAt(cursor) === charCode.backslash) cursor++;
+      else if (sql.charCodeAt(cursor) === charCode.singleQuote)
+        return cursor + 1;
+    }
+    return sql.length;
+  }
+  if (currentChar === charCode.backtick) {
+    const length = sql.length;
+    for (let cursor = position + 1; cursor < length; cursor++) {
+      if (sql.charCodeAt(cursor) !== charCode.backtick) continue;
+      if (sql.charCodeAt(cursor + 1) === charCode.backtick) {
+        cursor++;
+        continue;
+      }
+      return cursor + 1;
+    }
+    return length;
+  }
+  if (currentChar === charCode.dash && nextChar === charCode.dash) {
+    const lineBreak = sql.indexOf("\n", position + 2);
+    return lineBreak === -1 ? sql.length : lineBreak + 1;
+  }
+  if (currentChar === charCode.slash && nextChar === charCode.asterisk) {
+    const commentEnd = sql.indexOf("*/", position + 2);
+    return commentEnd === -1 ? sql.length : commentEnd + 2;
+  }
+  return -1;
+};
+const findNextPlaceholder = (sql, start) => {
+  const sqlLength = sql.length;
+  for (let position = start; position < sqlLength; position++) {
+    const code = sql.charCodeAt(position);
+    if (code === charCode.questionMark) return position;
+    if (code === charCode.singleQuote || code === charCode.backtick || code === charCode.dash || code === charCode.slash) {
+      const contextEnd = skipSqlContext(sql, position);
+      if (contextEnd !== -1) position = contextEnd - 1;
+    }
+  }
+  return -1;
+};
+const findSetKeyword = (sql, startFrom = 0) => {
+  const length = sql.length;
+  for (let position = startFrom; position < length; position++) {
+    const code = sql.charCodeAt(position);
+    const lower = code | 32;
+    if (code === charCode.singleQuote || code === charCode.backtick || code === charCode.dash || code === charCode.slash) {
+      const contextEnd = skipSqlContext(sql, position);
+      if (contextEnd !== -1) {
+        position = contextEnd - 1;
+        continue;
+      }
+    }
+    if (lower === 115 && matchesWord(sql, position, "set", length))
+      return position + 3;
+    if (lower === 107 && matchesWord(sql, position, "key", length)) {
+      let cursor = position + 3;
+      while (cursor < length && isWhitespace(sql.charCodeAt(cursor))) cursor++;
+      if (matchesWord(sql, cursor, "update", length)) return cursor + 6;
+    }
+  }
+  return -1;
+};
+const isDate = (value) => Object.prototype.toString.call(value) === "[object Date]";
+const hasSqlString = (value) => typeof value === "object" && value !== null && "toSqlString" in value && typeof value.toSqlString === "function";
+const escapeString = (value) => {
+  regex.escapeChars.lastIndex = 0;
+  let chunkIndex = 0;
+  let escapedValue = "";
+  let match;
+  for (match = regex.escapeChars.exec(value); match !== null; match = regex.escapeChars.exec(value)) {
+    escapedValue += value.slice(chunkIndex, match.index);
+    escapedValue += CHARS_ESCAPE_MAP[match[0]];
+    chunkIndex = regex.escapeChars.lastIndex;
+  }
+  if (chunkIndex === 0) return `'${value}'`;
+  if (chunkIndex < value.length)
+    return `'${escapedValue}${value.slice(chunkIndex)}'`;
+  return `'${escapedValue}'`;
+};
+const pad2 = (value) => value < 10 ? "0" + value : "" + value;
+const pad3 = (value) => value < 10 ? "00" + value : value < 100 ? "0" + value : "" + value;
+const pad4 = (value) => value < 10 ? "000" + value : value < 100 ? "00" + value : value < 1e3 ? "0" + value : "" + value;
+const convertTimezone = (tz) => {
+  if (tz === "Z") return 0;
+  const timezoneMatch = tz.match(regex.timezone);
+  if (timezoneMatch)
+    return (timezoneMatch[1] === "-" ? -1 : 1) * (Number.parseInt(timezoneMatch[2], 10) + (timezoneMatch[3] ? Number.parseInt(timezoneMatch[3], 10) : 0) / 60) * 60;
+  return false;
+};
+const dateToString = (date, timezone) => {
+  if (Number.isNaN(date.getTime())) return "NULL";
+  let year;
+  let month;
+  let day;
+  let hour;
+  let minute;
+  let second;
+  let millisecond;
+  if (timezone === "local") {
+    year = date.getFullYear();
+    month = date.getMonth() + 1;
+    day = date.getDate();
+    hour = date.getHours();
+    minute = date.getMinutes();
+    second = date.getSeconds();
+    millisecond = date.getMilliseconds();
+  } else {
+    const timezoneOffsetMinutes = convertTimezone(timezone);
+    let time = date.getTime();
+    if (timezoneOffsetMinutes !== false && timezoneOffsetMinutes !== 0)
+      time += timezoneOffsetMinutes * 6e4;
+    const adjustedDate = new Date(time);
+    year = adjustedDate.getUTCFullYear();
+    month = adjustedDate.getUTCMonth() + 1;
+    day = adjustedDate.getUTCDate();
+    hour = adjustedDate.getUTCHours();
+    minute = adjustedDate.getUTCMinutes();
+    second = adjustedDate.getUTCSeconds();
+    millisecond = adjustedDate.getUTCMilliseconds();
+  }
+  return escapeString(
+    pad4(year) + "-" + pad2(month) + "-" + pad2(day) + " " + pad2(hour) + ":" + pad2(minute) + ":" + pad2(second) + "." + pad3(millisecond)
+  );
+};
+const escapeId = (value, forbidQualified) => {
+  if (Array.isArray(value)) {
+    const length = value.length;
+    const parts = new Array(length);
+    for (let i = 0; i < length; i++)
+      parts[i] = escapeId(value[i], forbidQualified);
+    return parts.join(", ");
+  }
+  const identifier = String(value);
+  const hasJsonOperator = identifier.indexOf("->") !== -1;
+  if (forbidQualified || hasJsonOperator) {
+    if (identifier.indexOf("`") === -1) return `\`${identifier}\``;
+    return `\`${identifier.replace(regex.backtick, "``")}\``;
+  }
+  if (identifier.indexOf("`") === -1 && identifier.indexOf(".") === -1)
+    return `\`${identifier}\``;
+  return `\`${identifier.replace(regex.backtick, "``").replace(regex.dot, "`.`")}\``;
+};
+const objectToValues = (object, timezone) => {
+  const keys = Object.keys(object);
+  const keysLength = keys.length;
+  if (keysLength === 0) return "";
+  let sql = "";
+  for (let i = 0; i < keysLength; i++) {
+    const key = keys[i];
+    const value = object[key];
+    if (typeof value === "function") continue;
+    if (sql.length > 0) sql += ", ";
+    sql += escapeId(key);
+    sql += " = ";
+    sql += escape(value, true, timezone);
+  }
+  return sql;
+};
+const bufferToString = (buffer) => `X${escapeString(buffer.toString("hex"))}`;
+const arrayToList = (array, timezone) => {
+  const length = array.length;
+  const parts = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const value = array[i];
+    if (Array.isArray(value)) parts[i] = `(${arrayToList(value, timezone)})`;
+    else parts[i] = escape(value, true, timezone);
+  }
+  return parts.join(", ");
+};
+const escape = (value, stringifyObjects, timezone) => {
+  if (value === void 0 || value === null) return "NULL";
+  switch (typeof value) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+    case "bigint":
+      return value + "";
+    case "object": {
+      if (isDate(value)) return dateToString(value, timezone || "local");
+      if (Array.isArray(value)) return arrayToList(value, timezone);
+      if (Buffer.isBuffer(value)) return bufferToString(value);
+      if (value instanceof Uint8Array)
+        return bufferToString(Buffer.from(value));
+      if (hasSqlString(value)) return String(value.toSqlString());
+      if (!(stringifyObjects === void 0 || stringifyObjects === null))
+        return escapeString(String(value));
+      if (isRecord(value)) return objectToValues(value, timezone);
+      return escapeString(String(value));
+    }
+    case "string":
+      return escapeString(value);
+    default:
+      return escapeString(String(value));
+  }
+};
+const format = (sql, values, stringifyObjects, timezone) => {
+  if (values === void 0 || values === null) return sql;
+  const valuesArray = Array.isArray(values) ? values : [values];
+  const length = valuesArray.length;
+  let setIndex = -2;
+  let result = "";
+  let chunkIndex = 0;
+  let valuesIndex = 0;
+  let placeholderPosition = findNextPlaceholder(sql, 0);
+  while (valuesIndex < length && placeholderPosition !== -1) {
+    let placeholderEnd = placeholderPosition + 1;
+    let escapedValue;
+    while (sql.charCodeAt(placeholderEnd) === 63) placeholderEnd++;
+    const placeholderLength = placeholderEnd - placeholderPosition;
+    const currentValue = valuesArray[valuesIndex];
+    if (placeholderLength > 2) {
+      placeholderPosition = findNextPlaceholder(sql, placeholderEnd);
+      continue;
+    }
+    if (placeholderLength === 2) escapedValue = escapeId(currentValue);
+    else if (typeof currentValue === "number") escapedValue = `${currentValue}`;
+    else if (typeof currentValue === "object" && currentValue !== null && !stringifyObjects) {
+      if (setIndex === -2) setIndex = findSetKeyword(sql);
+      if (setIndex !== -1 && setIndex <= placeholderPosition && hasOnlyWhitespaceBetween(sql, setIndex, placeholderPosition) && !hasSqlString(currentValue) && !Array.isArray(currentValue) && !Buffer.isBuffer(currentValue) && !(currentValue instanceof Uint8Array) && !isDate(currentValue) && isRecord(currentValue)) {
+        escapedValue = objectToValues(currentValue, timezone);
+        setIndex = findSetKeyword(sql, placeholderEnd);
+      } else escapedValue = escape(currentValue, true, timezone);
+    } else escapedValue = escape(currentValue, stringifyObjects, timezone);
+    result += sql.slice(chunkIndex, placeholderPosition);
+    result += escapedValue;
+    chunkIndex = placeholderEnd;
+    valuesIndex++;
+    placeholderPosition = findNextPlaceholder(sql, placeholderEnd);
+  }
+  if (chunkIndex === 0) return sql;
+  if (chunkIndex < sql.length) return result + sql.slice(chunkIndex);
+  return result;
+};
+const raw = (sql) => {
+  if (typeof sql !== "string")
+    throw new TypeError("argument sql must be a string");
+  return {
+    toSqlString: () => sql
+  };
+};
+export {
+  arrayToList,
+  bufferToString,
+  dateToString,
+  escape,
+  escapeId,
+  format,
+  objectToValues,
+  raw
+};