burnless 0.1.0

package/dist/chunk-IBT7EFKB.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  src_default
+} from "./chunk-MHVBJUPX.js";
+import {
+  DefaultLogger,
+  NoopLogger,
+  PgDatabase,
+  PgDialect,
+  PgPreparedQuery,
+  PgSession,
+  PgTransaction,
+  createTableRelationsHelpers,
+  entityKind,
+  extractTablesRelationalConfig,
+  fillPlaceholders,
+  isConfig,
+  mapResultRow,
+  tracer
+} from "./chunk-RDP4RLLI.js";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.38.4_@electric-sql+pglite@0.5.2_@opentelemetry+api@1.9.0_@types+pg@8.15.6_75139cca41f10c6d94ac9ad65d4511ab/node_modules/drizzle-orm/postgres-js/session.js
+var PostgresJsPreparedQuery = class extends PgPreparedQuery {
+  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper) {
+    super({ sql: queryString, params });
+    this.client = client;
+    this.queryString = queryString;
+    this.params = params;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+  }
+  static [entityKind] = "PostgresJsPreparedQuery";
+  async execute(placeholderValues = {}) {
+    return tracer.startActiveSpan("drizzle.execute", async (span) => {
+      const params = fillPlaceholders(this.params, placeholderValues);
+      span?.setAttributes({
+        "drizzle.query.text": this.queryString,
+        "drizzle.query.params": JSON.stringify(params)
+      });
+      this.logger.logQuery(this.queryString, params);
+      const { fields, queryString: query, client, joinsNotNullableMap, customResultMapper } = this;
+      if (!fields && !customResultMapper) {
+        return tracer.startActiveSpan("drizzle.driver.execute", () => {
+          return client.unsafe(query, params);
+        });
+      }
+      const rows = await tracer.startActiveSpan("drizzle.driver.execute", () => {
+        span?.setAttributes({
+          "drizzle.query.text": query,
+          "drizzle.query.params": JSON.stringify(params)
+        });
+        return client.unsafe(query, params).values();
+      });
+      return tracer.startActiveSpan("drizzle.mapResponse", () => {
+        return customResultMapper ? customResultMapper(rows) : rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+      });
+    });
+  }
+  all(placeholderValues = {}) {
+    return tracer.startActiveSpan("drizzle.execute", async (span) => {
+      const params = fillPlaceholders(this.params, placeholderValues);
+      span?.setAttributes({
+        "drizzle.query.text": this.queryString,
+        "drizzle.query.params": JSON.stringify(params)
+      });
+      this.logger.logQuery(this.queryString, params);
+      return tracer.startActiveSpan("drizzle.driver.execute", () => {
+        span?.setAttributes({
+          "drizzle.query.text": this.queryString,
+          "drizzle.query.params": JSON.stringify(params)
+        });
+        return this.client.unsafe(this.queryString, params);
+      });
+    });
+  }
+  /** @internal */
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+};
+var PostgresJsSession = class _PostgresJsSession extends PgSession {
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  static [entityKind] = "PostgresJsSession";
+  logger;
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new PostgresJsPreparedQuery(
+      this.client,
+      query.sql,
+      query.params,
+      this.logger,
+      fields,
+      isResponseInArrayMode,
+      customResultMapper
+    );
+  }
+  query(query, params) {
+    this.logger.logQuery(query, params);
+    return this.client.unsafe(query, params).values();
+  }
+  queryObjects(query, params) {
+    return this.client.unsafe(query, params);
+  }
+  transaction(transaction, config) {
+    return this.client.begin(async (client) => {
+      const session = new _PostgresJsSession(
+        client,
+        this.dialect,
+        this.schema,
+        this.options
+      );
+      const tx = new PostgresJsTransaction(this.dialect, session, this.schema);
+      if (config) {
+        await tx.setTransaction(config);
+      }
+      return transaction(tx);
+    });
+  }
+};
+var PostgresJsTransaction = class _PostgresJsTransaction extends PgTransaction {
+  constructor(dialect, session, schema, nestedIndex = 0) {
+    super(dialect, session, schema, nestedIndex);
+    this.session = session;
+  }
+  static [entityKind] = "PostgresJsTransaction";
+  transaction(transaction) {
+    return this.session.client.savepoint((client) => {
+      const session = new PostgresJsSession(
+        client,
+        this.dialect,
+        this.schema,
+        this.session.options
+      );
+      const tx = new _PostgresJsTransaction(this.dialect, session, this.schema);
+      return transaction(tx);
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.38.4_@electric-sql+pglite@0.5.2_@opentelemetry+api@1.9.0_@types+pg@8.15.6_75139cca41f10c6d94ac9ad65d4511ab/node_modules/drizzle-orm/postgres-js/driver.js
+var PostgresJsDatabase = class extends PgDatabase {
+  static [entityKind] = "PostgresJsDatabase";
+};
+function construct(client, config = {}) {
+  const transparentParser = (val) => val;
+  for (const type of ["1184", "1082", "1083", "1114"]) {
+    client.options.parsers[type] = transparentParser;
+    client.options.serializers[type] = transparentParser;
+  }
+  client.options.serializers["114"] = transparentParser;
+  client.options.serializers["3802"] = transparentParser;
+  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 session = new PostgresJsSession(client, dialect, schema, { logger });
+  const db = new PostgresJsDatabase(dialect, session, schema);
+  db.$client = client;
+  return db;
+}
+function drizzle(...params) {
+  if (typeof params[0] === "string") {
+    const instance = src_default(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" && connection.url !== void 0) {
+      const { url, ...config } = connection;
+      const instance2 = src_default(url, config);
+      return construct(instance2, drizzleConfig);
+    }
+    const instance = src_default(connection);
+    return construct(instance, drizzleConfig);
+  }
+  return construct(params[0], params[1]);
+}
+((drizzle2) => {
+  function mock(config) {
+    return construct({
+      options: {
+        parsers: {},
+        serializers: {}
+      }
+    }, config);
+  }
+  drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+
+export {
+  PostgresJsPreparedQuery,
+  PostgresJsSession,
+  PostgresJsTransaction,
+  PostgresJsDatabase,
+  drizzle
+};