@kabyeon/nexusjs 0.6.5

package/dist/drizzle/index.js

@@ -0,0 +1,979 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/drizzle/types.ts
+import"reflect-metadata";
+var DRIZZLE_TABLE_META = "nexus:drizzle:table";
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/drizzle/drivers/postgres.ts
+var postgresDriver = async (config) => {
+  const conn = config.connection;
+  let driverName = "postgres-js";
+  let db;
+  let pool;
+  try {
+    const mod = await import("drizzle-orm/postgres-js");
+    const postgres = await import("postgres-js").catch(() => null) ?? null;
+    if (!postgres) {
+      throw new Error("postgres-js not installed");
+    }
+    const sql = postgres.default ? postgres.default(conn.url ?? thisBuildUrl(conn)) : postgres(conn.url ?? thisBuildUrl(conn));
+    pool = sql;
+    db = mod.drizzle(sql, {
+      schema: undefined,
+      logger: config.logging
+    });
+  } catch {
+    driverName = "node-postgres";
+    const drizzleMod = await import("drizzle-orm/node-postgres");
+    const pgMod = await import("pg");
+    const Pool = pgMod.Pool;
+    pool = new Pool({
+      host: conn.host,
+      port: conn.port,
+      user: conn.user,
+      password: conn.password,
+      database: conn.database,
+      ssl: conn.ssl,
+      max: conn.pool?.max ?? 10,
+      idleTimeoutMillis: conn.pool?.idleTimeoutMs,
+      connectionTimeoutMillis: conn.pool?.connectionTimeoutMs
+    });
+    db = drizzleMod.drizzle(pool, {
+      schema: undefined,
+      logger: config.logging
+    });
+  }
+  const rawExecutor = {
+    async query(sql, params2 = []) {
+      if (driverName === "postgres-js") {
+        const r = await pool.unsafe(sql, params2);
+        return { rows: r, affectedRows: r.length, insertId: undefined };
+      } else {
+        const r = await pool.query(sql, params2);
+        return {
+          rows: r.rows,
+          affectedRows: r.rowCount ?? 0,
+          insertId: undefined
+        };
+      }
+    },
+    placeholder: (i) => `$${i}`
+  };
+  return {
+    db,
+    dialect: "postgres",
+    rawExecutor,
+    async close() {
+      if (pool?.end)
+        await pool.end();
+    },
+    loadMigrator: async () => {
+      if (driverName === "postgres-js") {
+        const mod2 = await import("drizzle-orm/postgres-js/migrator");
+        return (folder) => mod2.migrate(db, {
+          migrationsFolder: folder,
+          migrationsSchema: config.schema
+        });
+      }
+      const mod = await import("drizzle-orm/node-postgres/migrator");
+      return (folder) => mod.migrate(db, {
+        migrationsFolder: folder,
+        migrationsSchema: config.schema
+      });
+    }
+  };
+};
+function thisBuildUrl(c) {
+  const user = encodeURIComponent(c.user ?? "");
+  const pass = encodeURIComponent(c.password ?? "");
+  const host = c.host ?? "localhost";
+  const port = c.port ?? 5432;
+  const db = c.database ?? "postgres";
+  return `postgres://${user}:${pass}@${host}:${port}/${db}`;
+}
+
+// src/drizzle/drivers/mysql.ts
+var mysqlDriver = async (config) => {
+  const conn = config.connection;
+  const drizzleMod = await import("drizzle-orm/mysql2");
+  const mysqlMod = await import("mysql2/promise");
+  const pool = mysqlMod.createPool({
+    host: conn.host,
+    port: conn.port,
+    user: conn.user,
+    password: conn.password,
+    database: conn.database,
+    connectionLimit: conn.pool?.max ?? 10,
+    ...conn
+  });
+  const db = drizzleMod.drizzle(pool, {
+    schema: undefined,
+    logger: config.logging
+  });
+  const rawExecutor = {
+    async query(sql, params2 = []) {
+      const [rows] = await pool.query(sql, params2);
+      return {
+        rows,
+        affectedRows: Array.isArray(rows) ? rows.length : 0,
+        insertId: undefined
+      };
+    },
+    placeholder: () => "?"
+  };
+  return {
+    db,
+    dialect: "mysql",
+    rawExecutor,
+    async close() {
+      if (pool?.end)
+        await pool.end();
+    },
+    loadMigrator: async () => {
+      const mod = await import("drizzle-orm/mysql2/migrator");
+      return (folder) => mod.migrate(db, { migrationsFolder: folder });
+    }
+  };
+};
+
+// src/drizzle/drivers/sqlite.ts
+var sqliteDriver = async (config) => {
+  const conn = config.connection;
+  const drizzleMod = await import("drizzle-orm/better-sqlite3");
+  const sqliteMod = await import("better-sqlite3");
+  const Database = sqliteMod.Database;
+  const sqlite = new Database(conn.filename, { readonly: conn.readonly });
+  const db = drizzleMod.drizzle(sqlite, {
+    schema: undefined,
+    logger: config.logging
+  });
+  const rawExecutor = {
+    async query(sql, params2 = []) {
+      const stmt = sqlite.prepare(sql);
+      const isSelect = /^\s*(select|pragma|with)\b/i.test(sql);
+      if (isSelect) {
+        const rows = stmt.all(...params2);
+        return { rows, affectedRows: 0 };
+      }
+      const r = stmt.run(...params2);
+      return {
+        rows: [],
+        affectedRows: r.changes,
+        insertId: r.lastInsertRowid
+      };
+    },
+    placeholder: () => "?"
+  };
+  return {
+    db,
+    dialect: "sqlite",
+    rawExecutor,
+    async close() {
+      if (sqlite?.close)
+        sqlite.close();
+    },
+    loadMigrator: async () => {
+      const mod = await import("drizzle-orm/better-sqlite3/migrator");
+      return (folder) => mod.migrate(db, { migrationsFolder: folder });
+    }
+  };
+};
+
+// src/drizzle/drivers/bun-sqlite.ts
+var bunSqliteDriver = async (config) => {
+  const conn = config.connection;
+  const drizzleMod = await import("drizzle-orm/bun-sqlite");
+  const { Database } = await import("bun:sqlite");
+  const sqlite = new Database(conn.filename);
+  const db = drizzleMod.drizzle(sqlite, {
+    schema: undefined,
+    logger: config.logging
+  });
+  const rawExecutor = {
+    async query(sql, params2 = []) {
+      const stmt = sqlite.prepare(sql);
+      const isSelect = /^\s*(select|pragma|with)\b/i.test(sql);
+      if (isSelect) {
+        const rows = stmt.all(...params2);
+        return { rows, affectedRows: 0 };
+      }
+      const r = stmt.run(...params2);
+      return {
+        rows: [],
+        affectedRows: Number(r.changes ?? 0),
+        insertId: r.lastInsertRowid
+      };
+    },
+    placeholder: () => "?"
+  };
+  return {
+    db,
+    dialect: "bun-sqlite",
+    rawExecutor,
+    async close() {
+      if (sqlite?.close)
+        sqlite.close();
+    },
+    loadMigrator: async () => {
+      const mod = await import("drizzle-orm/better-sqlite3/migrator");
+      return (folder) => mod.migrate(db, { migrationsFolder: folder });
+    }
+  };
+};
+
+// src/drizzle/drivers/d1.ts
+var d1Driver = async (config) => {
+  const conn = config.connection;
+  if (!conn.binding) {
+    throw new Error("d1 driver requires `connection.binding` (a D1Database)");
+  }
+  const drizzleMod = await import("drizzle-orm/d1");
+  const db = drizzleMod.drizzle(conn.binding, {
+    schema: undefined,
+    logger: config.logging
+  });
+  const binding = conn.binding;
+  const rawExecutor = {
+    async query(sql, params2 = []) {
+      const stmt = binding.prepare(sql);
+      const lower = sql.trim().toLowerCase();
+      if (lower.startsWith("select") || lower.startsWith("pragma") || lower.startsWith("with")) {
+        const r2 = await stmt.bind(...params2).all();
+        return {
+          rows: r2.results ?? [],
+          affectedRows: (r2.results ?? []).length
+        };
+      }
+      const r = await stmt.bind(...params2).run();
+      return {
+        rows: [],
+        affectedRows: r.meta?.changes ?? 0,
+        insertId: r.meta?.last_row_id
+      };
+    },
+    placeholder: () => "?"
+  };
+  return {
+    db,
+    dialect: "d1",
+    rawExecutor,
+    close: undefined,
+    loadMigrator: undefined
+  };
+};
+
+// src/drizzle/drivers/index.ts
+async function resolveDriver(config) {
+  switch (config.dialect) {
+    case "postgres":
+      return postgresDriver(config);
+    case "mysql":
+      return mysqlDriver(config);
+    case "sqlite":
+      return sqliteDriver(config);
+    case "bun-sqlite":
+      return bunSqliteDriver(config);
+    case "d1":
+      return d1Driver(config);
+  }
+}
+
+// src/drizzle/raw-query.ts
+class RawQuery {
+  sqlText;
+  params;
+  executor;
+  logger;
+  constructor(sqlText, params2, executor, logger) {
+    this.sqlText = sqlText;
+    this.params = params2;
+    this.executor = executor;
+    this.logger = logger;
+  }
+  async all() {
+    const r = await this.run();
+    return r.rows;
+  }
+  async first() {
+    const r = await this.run();
+    return r.rows[0];
+  }
+  async execute() {
+    return this.run();
+  }
+  toSQL() {
+    return this.sqlText;
+  }
+  getParameters() {
+    return [...this.params];
+  }
+  async run() {
+    if (this.logger)
+      this.logger(this.sqlText, this.params);
+    const r = await this.executor.query(this.sqlText, this.params);
+    return {
+      rows: r.rows,
+      affectedRows: r.affectedRows,
+      insertId: r.insertId
+    };
+  }
+}
+
+// src/drizzle/drizzle.service.ts
+class DrizzleService {
+  static TOKEN = Symbol.for("nexus:DrizzleService");
+  driver = null;
+  _client = null;
+  _rawExecutor = null;
+  _config;
+  _opened = false;
+  _migratorFn = null;
+  _logger = null;
+  _migrationsTable = "__nexus_migrations";
+  constructor(config) {
+    this._config = config;
+    if (config.dialect === "bun-sqlite" || config.connection?.filename) {
+      this.openSync();
+    }
+  }
+  openSync() {
+    try {
+      const conn = this._config.connection;
+      const { Database } = __require("bun:sqlite");
+      const sqlite = new Database(conn?.filename ?? this._config.url ?? "app.db");
+      const { drizzle } = __require("drizzle-orm/bun-sqlite");
+      this._client = drizzle(sqlite, { logger: this._config.logging });
+      this._rawExecutor = {
+        query: async (sql, params2 = []) => {
+          const stmt = sqlite.prepare(sql);
+          const isSelect = /^\s*(select|pragma|with)\b/i.test(sql);
+          if (isSelect) {
+            const rows = stmt.all(...params2);
+            return { rows, affectedRows: 0 };
+          }
+          const r = stmt.run(...params2);
+          return {
+            rows: [],
+            affectedRows: Number(r.changes ?? 0),
+            insertId: r.lastInsertRowid
+          };
+        },
+        placeholder: () => "?"
+      };
+      this.driver = {
+        db: this._client,
+        dialect: "bun-sqlite"
+      };
+      this._opened = true;
+    } catch {}
+  }
+  async open() {
+    if (this._opened)
+      return;
+    const drv = await resolveDriver(this._config);
+    this.driver = drv;
+    this._client = drv.db;
+    this._rawExecutor = drv.rawExecutor ?? null;
+    if (this._config.logging) {
+      this._logger = typeof this._config.logging === "function" ? this._config.logging : (q, p) => {
+        const trimmed = q.replace(/\s+/g, " ").trim();
+        if (p.length === 0)
+          console.log(`[drizzle] ${trimmed}`);
+        else
+          console.log(`[drizzle] ${trimmed}  -- params: ${JSON.stringify(p)}`);
+      };
+    }
+    if (drv.loadMigrator) {
+      this._migratorFn = await drv.loadMigrator();
+    }
+    if (this._config.autoMigrate && this._config.migrationsFolder && this._migratorFn) {
+      await this.migrate(this._config.migrationsFolder);
+    }
+    this._opened = true;
+  }
+  get client() {
+    this._assertOpen();
+    return this._client;
+  }
+  get dialect() {
+    return this._config.dialect;
+  }
+  select() {
+    return this.client.select();
+  }
+  insert(table) {
+    return this.client.insert(table);
+  }
+  update(table) {
+    return this.client.update(table);
+  }
+  delete(table) {
+    return this.client.delete(table);
+  }
+  async transaction(fn) {
+    this._assertOpen();
+    return this.client.transaction(async (tx) => {
+      const txService = Object.create(this);
+      Object.defineProperty(txService, "_client", { value: tx, writable: false });
+      return fn(txService);
+    });
+  }
+  raw(strings, ...values) {
+    if (!this._rawExecutor) {
+      throw new Error("[drizzle] driver does not support raw queries");
+    }
+    const text = buildSqlText(strings);
+    return new RawQuery(text, values, this._rawExecutor, this._logger ?? undefined);
+  }
+  async rawQuery(sql, params2 = []) {
+    if (!this._rawExecutor) {
+      throw new Error("[drizzle] driver does not support raw queries");
+    }
+    const r = new RawQuery(sql, params2, this._rawExecutor, this._logger ?? undefined);
+    return r.all();
+  }
+  async migrate(folder) {
+    if (!this._migratorFn) {
+      throw new Error(`[drizzle] this dialect (${this._config.dialect}) does not ship a built-in migrator. ` + `Run migrations manually using drizzle-kit.`);
+    }
+    await this._migratorFn(folder);
+    const applied = await this.appliedMigrations();
+    return { applied, total: applied.length };
+  }
+  async appliedMigrations() {
+    try {
+      const r = await this.rawQuery(`SELECT id, hash, created_at FROM ${this._migrationsTable} ORDER BY id`);
+      return r.map((row) => ({
+        id: Number(row.id),
+        hash: String(row.hash),
+        appliedAt: parseTimestamp(row.created_at)
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async close() {
+    if (!this._opened)
+      return;
+    if (this.driver?.close)
+      await this.driver.close();
+    this._opened = false;
+    this._client = null;
+    this._rawExecutor = null;
+  }
+  attachLogger(fn) {
+    this._logger = fn;
+  }
+  _assertOpen() {
+    if (!this._opened) {
+      throw new Error("[drizzle] service not opened. Call open() first.");
+    }
+  }
+}
+DrizzleService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("DRIZZLE_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DrizzleConfig === "undefined" ? Object : DrizzleConfig
+  ])
+], DrizzleService);
+function buildSqlText(strings) {
+  let s = strings[0] ?? "";
+  for (let i = 0;i < strings.length - 1; i++) {
+    s += "?";
+    s += strings[i + 1];
+  }
+  return s;
+}
+function parseTimestamp(v) {
+  if (v instanceof Date)
+    return v;
+  if (typeof v === "number")
+    return new Date(v);
+  return new Date(String(v));
+}
+// src/drizzle/drizzle.module.ts
+import"reflect-metadata";
+class DrizzleModule {
+  static forRoot(config) {
+    class ConfiguredDrizzleModule {
+    }
+    ConfiguredDrizzleModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          DrizzleService,
+          { provide: DrizzleService.TOKEN, useExisting: DrizzleService },
+          { provide: "DRIZZLE_CONFIG", useValue: config }
+        ],
+        exports: [DrizzleService, DrizzleService.TOKEN]
+      })
+    ], ConfiguredDrizzleModule);
+    Object.defineProperty(ConfiguredDrizzleModule, "name", {
+      value: "ConfiguredDrizzleModule"
+    });
+    return ConfiguredDrizzleModule;
+  }
+}
+DrizzleModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      DrizzleService,
+      { provide: DrizzleService.TOKEN, useExisting: DrizzleService }
+    ],
+    exports: [DrizzleService, DrizzleService.TOKEN]
+  })
+], DrizzleModule);
+// src/drizzle/decorators/columns.ts
+import"reflect-metadata";
+function Table(name) {
+  return (target) => {
+    const existing = Reflect.getMetadata(DRIZZLE_TABLE_META, target) ?? {
+      name,
+      columns: new Map
+    };
+    existing.name = name;
+    Reflect.defineMetadata(DRIZZLE_TABLE_META, existing, target);
+  };
+}
+function Column(opts = {}) {
+  return (target, propertyKey) => {
+    const meta = getTableMeta(target.constructor);
+    meta.columns.set(String(propertyKey), {
+      name: opts.name ?? String(propertyKey),
+      type: opts.type ?? "text",
+      nullable: opts.nullable ?? false,
+      primaryKey: opts.primaryKey ?? false,
+      autoIncrement: opts.autoIncrement ?? false,
+      unique: opts.unique ?? false,
+      default: opts.default,
+      references: opts.references
+    });
+  };
+}
+function PrimaryKey(opts = {}) {
+  return (target, propertyKey) => {
+    const meta = getTableMeta(target.constructor);
+    meta.columns.set(String(propertyKey), {
+      name: opts.name ?? String(propertyKey),
+      type: opts.type ?? "integer",
+      nullable: false,
+      primaryKey: true,
+      autoIncrement: opts.autoIncrement ?? false,
+      unique: true,
+      default: opts.default
+    });
+  };
+}
+function getTableMeta(target) {
+  const m = Reflect.getMetadata(DRIZZLE_TABLE_META, target) ?? {
+    name: target.name.toLowerCase(),
+    columns: new Map
+  };
+  Reflect.defineMetadata(DRIZZLE_TABLE_META, m, target);
+  return m;
+}
+function readTableMeta(target) {
+  return Reflect.getMetadata(DRIZZLE_TABLE_META, target);
+}
+// src/drizzle/model.ts
+class DrizzleModel {
+  static getMeta() {
+    return readTableMeta(DrizzleModel);
+  }
+  static getTableName() {
+    return readTableMeta(DrizzleModel)?.name;
+  }
+  toJSON() {
+    const out = {};
+    for (const [k, v] of Object.entries(this)) {
+      if (typeof v !== "function")
+        out[k] = v;
+    }
+    return out;
+  }
+}
+// src/drizzle/repository/repository.ts
+class DrizzleRepository {
+  db;
+  table;
+  constructor(db, table) {
+    this.db = db;
+    this.table = table;
+  }
+  get client() {
+    return this.db.client;
+  }
+  async findAll(opts = {}) {
+    let q = this.db.client.select().from(this.table);
+    if (opts.where)
+      q = q.where(opts.where);
+    if (opts.orderBy) {
+      const arr = Array.isArray(opts.orderBy) ? opts.orderBy : [opts.orderBy];
+      q = q.orderBy(...arr);
+    }
+    if (opts.limit !== undefined)
+      q = q.limit(opts.limit);
+    if (opts.offset !== undefined)
+      q = q.offset(opts.offset);
+    const result = q.all ? await q.all() : await q;
+    return result;
+  }
+  async findOne(where) {
+    const rows = await this.findAll({ where, limit: 1 });
+    return rows[0];
+  }
+  async count(where) {
+    const tableName = this._tableName();
+    const rows = where ? await this.db.rawQuery(`SELECT COUNT(*) as count FROM ${tableName} WHERE ${whereSql(where)}`, whereParams(where)) : await this.db.rawQuery(`SELECT COUNT(*) as count FROM ${tableName}`);
+    return Number(rows[0]?.count ?? 0);
+  }
+  async create(values) {
+    const isArr = Array.isArray(values);
+    const q = this.db.client.insert(this.table).values(values).returning();
+    const rows = await q;
+    return isArr ? rows : rows[0];
+  }
+  async update(where, patch) {
+    const q = this.db.client.update(this.table).set(patch).where(where).returning();
+    return await q;
+  }
+  async delete(where) {
+    const tableName = this._tableName();
+    const r = await this.db.rawQuery(`DELETE FROM ${tableName} WHERE ${whereSql(where)}`, whereParams(where));
+    return r.length;
+  }
+  async transaction(fn) {
+    return this.db.transaction(async (txDb) => {
+      const txRepo = Object.create(this);
+      Object.defineProperty(txRepo, "db", { value: txDb, writable: false });
+      return fn(txRepo);
+    });
+  }
+  _tableName() {
+    const t = this.table;
+    return t?._?.name ?? t?.name ?? String(t);
+  }
+}
+function whereSql(where) {
+  if (where && typeof where === "object" && !Array.isArray(where) && !where.queryChunks) {
+    const parts = [];
+    for (const k of Object.keys(where))
+      parts.push(`${k} = ?`);
+    return parts.join(" AND ");
+  }
+  return drizzleSqlToText(where).text;
+}
+function whereParams(where) {
+  if (where && typeof where === "object" && !Array.isArray(where) && !where.queryChunks) {
+    return Object.values(where);
+  }
+  return drizzleSqlToText(where).params;
+}
+function drizzleSqlToText(node, out) {
+  out = out ?? { text: "", params: [] };
+  if (node === null || node === undefined)
+    return out;
+  if (typeof node === "string") {
+    out.text += node;
+    return out;
+  }
+  if (typeof node === "number" || typeof node === "boolean") {
+    out.text += String(node);
+    return out;
+  }
+  if (Array.isArray(node)) {
+    for (const c of node)
+      drizzleSqlToText(c, out);
+    return out;
+  }
+  if (node.queryChunks && Array.isArray(node.queryChunks)) {
+    for (const c of node.queryChunks)
+      drizzleSqlToText(c, out);
+    return out;
+  }
+  if ("value" in node && node.value !== undefined) {
+    out.text += "?";
+    out.params.push(node.value);
+    return out;
+  }
+  if (typeof node.getSQL === "function") {
+    return drizzleSqlToText(node.getSQL(), out);
+  }
+  return out;
+}
+export {
+  sqliteDriver,
+  resolveDriver,
+  readTableMeta,
+  postgresDriver,
+  mysqlDriver,
+  getTableMeta,
+  d1Driver,
+  bunSqliteDriver,
+  Table,
+  RawQuery,
+  PrimaryKey,
+  DrizzleService,
+  DrizzleRepository,
+  DrizzleModule,
+  DrizzleModel,
+  DRIZZLE_TABLE_META,
+  Column
+};
+
+//# debugId=FB207F5418791DF864756E2164756E21
+//# sourceMappingURL=index.js.map