Initial commit: New MoreminiMore website with fresh design

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

@@ -0,0 +1,156 @@
+import { entityKind } from "../entity.js";
+import { NoopLogger } from "../logger.js";
+import { PgTransaction } from "../pg-core/index.js";
+import { PgPreparedQuery, PgSession } from "../pg-core/session.js";
+import { fillPlaceholders } from "../sql/sql.js";
+import { mapResultRow } from "../utils.js";
+const rawQueryConfig = {
+  arrayMode: false,
+  fullResults: true
+};
+const queryConfig = {
+  arrayMode: true,
+  fullResults: true
+};
+class NeonHttpPreparedQuery extends PgPreparedQuery {
+  constructor(client, query, logger, fields, _isResponseInArrayMode, customResultMapper) {
+    super(query);
+    this.client = client;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+    this.clientQuery = client.query ?? client;
+  }
+  static [entityKind] = "NeonHttpPreparedQuery";
+  clientQuery;
+  /** @internal */
+  async execute(placeholderValues = {}, token = this.authToken) {
+    const params = fillPlaceholders(this.query.params, placeholderValues);
+    this.logger.logQuery(this.query.sql, params);
+    const { fields, clientQuery, query, customResultMapper } = this;
+    if (!fields && !customResultMapper) {
+      return clientQuery(
+        query.sql,
+        params,
+        token === void 0 ? rawQueryConfig : {
+          ...rawQueryConfig,
+          authToken: token
+        }
+      );
+    }
+    const result = await clientQuery(
+      query.sql,
+      params,
+      token === void 0 ? queryConfig : {
+        ...queryConfig,
+        authToken: token
+      }
+    );
+    return this.mapResult(result);
+  }
+  mapResult(result) {
+    if (!this.fields && !this.customResultMapper) {
+      return result;
+    }
+    const rows = result.rows;
+    if (this.customResultMapper) {
+      return this.customResultMapper(rows);
+    }
+    return rows.map((row) => mapResultRow(this.fields, row, this.joinsNotNullableMap));
+  }
+  all(placeholderValues = {}) {
+    const params = fillPlaceholders(this.query.params, placeholderValues);
+    this.logger.logQuery(this.query.sql, params);
+    return this.clientQuery(
+      this.query.sql,
+      params,
+      this.authToken === void 0 ? rawQueryConfig : {
+        ...rawQueryConfig,
+        authToken: this.authToken
+      }
+    ).then((result) => result.rows);
+  }
+  /** @internal */
+  values(placeholderValues = {}, token) {
+    const params = fillPlaceholders(this.query.params, placeholderValues);
+    this.logger.logQuery(this.query.sql, params);
+    return this.clientQuery(this.query.sql, params, { arrayMode: true, fullResults: true, authToken: token }).then((result) => result.rows);
+  }
+  /** @internal */
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+}
+class NeonHttpSession extends PgSession {
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.clientQuery = client.query ?? client;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  static [entityKind] = "NeonHttpSession";
+  clientQuery;
+  logger;
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new NeonHttpPreparedQuery(
+      this.client,
+      query,
+      this.logger,
+      fields,
+      isResponseInArrayMode,
+      customResultMapper
+    );
+  }
+  async batch(queries) {
+    const preparedQueries = [];
+    const builtQueries = [];
+    for (const query of queries) {
+      const preparedQuery = query._prepare();
+      const builtQuery = preparedQuery.getQuery();
+      preparedQueries.push(preparedQuery);
+      builtQueries.push(
+        this.clientQuery(builtQuery.sql, builtQuery.params, {
+          fullResults: true,
+          arrayMode: preparedQuery.isResponseInArrayMode()
+        })
+      );
+    }
+    const batchResults = await this.client.transaction(builtQueries, queryConfig);
+    return batchResults.map((result, i) => preparedQueries[i].mapResult(result, true));
+  }
+  // change return type to QueryRows<true>
+  async query(query, params) {
+    this.logger.logQuery(query, params);
+    const result = await this.clientQuery(query, params, { arrayMode: true, fullResults: true });
+    return result;
+  }
+  // change return type to QueryRows<false>
+  async queryObjects(query, params) {
+    return this.clientQuery(query, params, { arrayMode: false, fullResults: true });
+  }
+  /** @internal */
+  async count(sql, token) {
+    const res = await this.execute(sql, token);
+    return Number(
+      res["rows"][0]["count"]
+    );
+  }
+  async transaction(_transaction, _config = {}) {
+    throw new Error("No transactions support in neon-http driver");
+  }
+}
+class NeonTransaction extends PgTransaction {
+  static [entityKind] = "NeonHttpTransaction";
+  async transaction(_transaction) {
+    throw new Error("No transactions support in neon-http driver");
+  }
+}
+export {
+  NeonHttpPreparedQuery,
+  NeonHttpSession,
+  NeonTransaction
+};
+//# sourceMappingURL=session.js.map