Initial commit

node_modules/drizzle-orm/neon-http/driver.js

@@ -0,0 +1,124 @@
+import { neon, types } from "@neondatabase/serverless";
+import { entityKind } from "../entity.js";
+import { DefaultLogger } from "../logger.js";
+import { PgDatabase } from "../pg-core/db.js";
+import { PgDialect } from "../pg-core/dialect.js";
+import { createTableRelationsHelpers, extractTablesRelationalConfig } from "../relations.js";
+import { isConfig } from "../utils.js";
+import { NeonHttpSession } from "./session.js";
+class NeonHttpDriver {
+  constructor(client, dialect, options = {}) {
+    this.client = client;
+    this.dialect = dialect;
+    this.options = options;
+    this.initMappers();
+  }
+  static [entityKind] = "NeonHttpDriver";
+  createSession(schema) {
+    return new NeonHttpSession(this.client, this.dialect, schema, { logger: this.options.logger });
+  }
+  initMappers() {
+    types.setTypeParser(types.builtins.TIMESTAMPTZ, (val) => val);
+    types.setTypeParser(types.builtins.TIMESTAMP, (val) => val);
+    types.setTypeParser(types.builtins.DATE, (val) => val);
+    types.setTypeParser(types.builtins.INTERVAL, (val) => val);
+  }
+}
+function wrap(target, token, cb, deep) {
+  return new Proxy(target, {
+    get(target2, p) {
+      const element = target2[p];
+      if (typeof element !== "function" && (typeof element !== "object" || element === null))
+        return element;
+      if (deep)
+        return wrap(element, token, cb);
+      if (p === "query")
+        return wrap(element, token, cb, true);
+      return new Proxy(element, {
+        apply(target3, thisArg, argArray) {
+          const res = target3.call(thisArg, ...argArray);
+          if (typeof res === "object" && res !== null && "setToken" in res && typeof res.setToken === "function") {
+            res.setToken(token);
+          }
+          return cb(target3, p, res);
+        }
+      });
+    }
+  });
+}
+class NeonHttpDatabase extends PgDatabase {
+  static [entityKind] = "NeonHttpDatabase";
+  $withAuth(token) {
+    this.authToken = token;
+    return wrap(this, token, (target, p, res) => {
+      if (p === "with") {
+        return wrap(res, token, (_, __, res2) => res2);
+      }
+      return res;
+    });
+  }
+  async batch(batch) {
+    return this.session.batch(batch);
+  }
+}
+function construct(client, config = {}) {
+  const dialect = new PgDialect({ casing: config.casing });
+  let logger;
+  if (config.logger === true) {
+    logger = new DefaultLogger();
+  } else if (config.logger !== false) {
+    logger = config.logger;
+  }
+  let schema;
+  if (config.schema) {
+    const tablesConfig = extractTablesRelationalConfig(
+      config.schema,
+      createTableRelationsHelpers
+    );
+    schema = {
+      fullSchema: config.schema,
+      schema: tablesConfig.tables,
+      tableNamesMap: tablesConfig.tableNamesMap
+    };
+  }
+  const driver = new NeonHttpDriver(client, dialect, { logger });
+  const session = driver.createSession(schema);
+  const db = new NeonHttpDatabase(
+    dialect,
+    session,
+    schema
+  );
+  db.$client = client;
+  return db;
+}
+function drizzle(...params) {
+  if (typeof params[0] === "string") {
+    const instance = neon(params[0]);
+    return construct(instance, params[1]);
+  }
+  if (isConfig(params[0])) {
+    const { connection, client, ...drizzleConfig } = params[0];
+    if (client)
+      return construct(client, drizzleConfig);
+    if (typeof connection === "object") {
+      const { connectionString, ...options } = connection;
+      const instance2 = neon(connectionString, options);
+      return construct(instance2, drizzleConfig);
+    }
+    const instance = neon(connection);
+    return construct(instance, drizzleConfig);
+  }
+  return construct(params[0], params[1]);
+}
+((drizzle2) => {
+  function mock(config) {
+    return construct({}, config);
+  }
+  drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+export {
+  NeonHttpDatabase,
+  NeonHttpDriver,
+  drizzle
+};
+//# sourceMappingURL=driver.js.map