@absolutejs/auth 0.75.6 → 0.75.7

package/dist/vault/index.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -58,20 +60,20 @@ var init_constants = __esm(() => {
 // src/crypto.ts
 var exports_crypto = {};
 __export(exports_crypto, {
-  verifyTotp: () => verifyTotp,
-  verifyPassword: () => verifyPassword,
-  hashToken: () => hashToken,
-  hashPassword: () => hashPassword,
-  generateTotpSecret: () => generateTotpSecret,
-  generateTotp: () => generateTotp,
-  generateSecureToken: () => generateSecureToken,
-  generateEncryptionKey: () => generateEncryptionKey,
-  encryptSecret: () => encryptSecret,
-  decryptSecret: () => decryptSecret,
-  createTotpKeyUri: () => createTotpKeyUri,
-  constantTimeEqual: () => constantTimeEqual,
+  base32Decode: () => base32Decode,
   base32Encode: () => base32Encode,
-  base32Decode: () => base32Decode
+  constantTimeEqual: () => constantTimeEqual,
+  createTotpKeyUri: () => createTotpKeyUri,
+  decryptSecret: () => decryptSecret,
+  encryptSecret: () => encryptSecret,
+  generateEncryptionKey: () => generateEncryptionKey,
+  generateSecureToken: () => generateSecureToken,
+  generateTotp: () => generateTotp,
+  generateTotpSecret: () => generateTotpSecret,
+  hashPassword: () => hashPassword,
+  hashToken: () => hashToken,
+  verifyPassword: () => verifyPassword,
+  verifyTotp: () => verifyTotp
 });
 var DEFAULT_TOKEN_BYTES = 32, AES_KEY_BYTES = 32, AES_IV_BYTES = 12, HOTP_COUNTER_BYTES = 8, TOTP_SECRET_BYTES = 20, TOTP_DIGITS = 6, TOTP_PERIOD_SECONDS = 30, DEFAULT_TOTP_WINDOW = 1, DECIMAL_RADIX = 10, LAST_NIBBLE_MASK = 15, SIGN_BIT_MASK = 2147483647, BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", BASE32_GROUP_BITS = 5, BASE32_MASK = 31, BYTE_BITS = 8, textEncoder, textDecoder, base64UrlEncode = (bytes) => Buffer.from(bytes).toString("base64url"), base64UrlDecode = (encoded) => new Uint8Array(Buffer.from(encoded, "base64url")), sha256 = async (input) => {
   const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(input));
@@ -453,6 +455,9 @@ var tracer = { startActiveSpan(name, fn) {
 var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
 
 // node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
 function isSQLWrapper(value) {
   return value !== null && value !== undefined && typeof value.getSQL === "function";
 }
@@ -4130,6 +4135,16 @@ var UniqueConstraintBuilder = class {
     return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
   }
 };
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  name;
+  constructor(name2) {
+    this.name = name2;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+};
 var UniqueConstraint = class {
   static [entityKind] = "PgUniqueConstraint";
   columns;
@@ -9405,6 +9420,17 @@ var ColumnAliasProxyHandler2 = class {
     return target[prop];
   }
 };
+var RelationTableAliasProxyHandler2 = class {
+  static [entityKind] = "RelationTableAliasProxyHandler";
+  constructor(alias2) {
+    this.alias = alias2;
+  }
+  get(target, prop) {
+    if (prop === "sourceTable")
+      return aliasedTable2(target.sourceTable, this.alias);
+    return target[prop];
+  }
+};
 function aliasedTable2(table, tableAlias) {
   return new Proxy(table, new TableAliasProxyHandler2(tableAlias, false, false));
 }
@@ -9888,6 +9914,13 @@ params: ${params}`);
       this.cause = cause;
   }
 };
+var TransactionRollbackError2 = class extends DrizzleError2 {
+  static [entityKind] = "TransactionRollbackError";
+  constructor() {
+    super({ message: "Rollback" });
+    this.name = "TransactionRollbackError";
+  }
+};
 // node_modules/drizzle-orm/relations.js
 var Relation2 = class {
   static [entityKind] = "RelationV2";
@@ -9936,6 +9969,53 @@ var One2 = class extends Relation2 {
     this.optional = config?.optional ?? true;
   }
 };
+var Many2 = class extends Relation2 {
+  static [entityKind] = "ManyV2";
+  relationType = "many";
+  constructor(tables, targetTable, targetTableName, config) {
+    super(targetTable, targetTableName);
+    this.config = config;
+    this.alias = config?.alias;
+    this.where = config?.where;
+    if (config?.from)
+      this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it2) => {
+        this.throughTable ??= it2._.through ? tables[it2._.through._.tableName] : undefined;
+        this.sourceColumnTableNames.push(it2._.tableName);
+        return it2._.column;
+      });
+    if (config?.to)
+      this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it2) => {
+        this.throughTable ??= it2._.through ? tables[it2._.through._.tableName] : undefined;
+        this.targetColumnTableNames.push(it2._.tableName);
+        return it2._.column;
+      });
+    if (this.throughTable)
+      this.through = {
+        source: (Array.isArray(config?.from) ? config.from : (config?.from) ? [config.from] : []).map((c) => c._.through),
+        target: (Array.isArray(config?.to) ? config.to : (config?.to) ? [config.to] : []).map((c) => c._.through)
+      };
+  }
+};
+var AggregatedField2 = class {
+  static [entityKind] = "AggregatedField";
+  table;
+  onTable(table) {
+    this.table = table;
+    return this;
+  }
+};
+var Count2 = class extends AggregatedField2 {
+  static [entityKind] = "AggregatedFieldCount";
+  query;
+  getSQL() {
+    if (!this.query) {
+      if (!this.table)
+        throw new Error("Table must be set before building aggregate field");
+      this.query = sql`select count(*) as ${sql.identifier("r")} from ${getTableAsAliasSQL2(this.table)}`.mapWith(Number);
+    }
+    return this.query;
+  }
+};
 var operators2 = {
   and,
   between,
@@ -10256,6 +10336,66 @@ function makeJitRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, r
 ${compiled}
 }` });
 }
+var RelationsBuilderTable2 = class {
+  static [entityKind] = "RelationsBuilderTable";
+  _;
+  constructor(table, name2) {
+    this._ = {
+      name: name2,
+      table
+    };
+  }
+};
+var RelationsBuilderColumn2 = class {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key) {
+    this._ = {
+      tableName,
+      column,
+      key
+    };
+  }
+  through(column) {
+    return new RelationsBuilderJunctionColumn2(this._.column, this._.tableName, this._.key, column);
+  }
+};
+var RelationsBuilderJunctionColumn2 = class {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key, through) {
+    this._ = {
+      tableName,
+      column,
+      through,
+      key
+    };
+  }
+};
+var RelationsHelperStatic2 = class {
+  static [entityKind] = "RelationsHelperStatic";
+  _;
+  constructor(tables) {
+    this._ = { tables };
+    const one = {};
+    const many = {};
+    for (const [tableName, table] of Object.entries(tables)) {
+      one[tableName] = (config) => {
+        return new One2(tables, table, tableName, config);
+      };
+      many[tableName] = (config) => {
+        return new Many2(tables, table, tableName, config);
+      };
+    }
+    this.one = one;
+    this.many = many;
+  }
+  one;
+  many;
+  aggs = { count() {
+    return new Count2;
+  } };
+};
 function fieldSelectionToSQL2(table, target) {
   const field = table[TableColumns][target];
   return field ? is(field, Column) ? field : is(field, SQL.Aliased) ? sql`${table}.${sql.identifier(field.fieldAlias)}` : sql`${table}.${sql.identifier(target)}` : sql`${table}.${sql.identifier(target)}`;
@@ -11714,6 +11854,29 @@ var PgAsyncSession2 = class extends PgSession2 {
     });
   }
 };
+var PgAsyncTransaction2 = class extends PgAsyncDatabase2 {
+  static [entityKind] = "PgAsyncTransaction";
+  constructor(dialect, session, relations, nestedIndex = 0, parseRqbJson) {
+    super(dialect, session, relations, parseRqbJson);
+    this.nestedIndex = nestedIndex;
+  }
+  rollback() {
+    throw new TransactionRollbackError2;
+  }
+  getTransactionConfigSQL(config) {
+    const chunks = [];
+    if (config.isolationLevel)
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    if (config.accessMode)
+      chunks.push(config.accessMode);
+    if (typeof config.deferrable === "boolean")
+      chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+    return sql.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+  }
+};
 
 // node_modules/drizzle-orm/neon-http/session.js
 var NeonHttpSession = class extends PgAsyncSession2 {
@@ -11887,15 +12050,15 @@ var createPostgresVaultStore = (db) => ({
   }
 });
 export {
-  vaultEntriesTable,
-  rotateVaultKey,
-  createVersionedSecretCipher,
-  createVault,
-  createSecretCipher,
-  createPostgresVaultStore,
+  createInMemoryVaultStore,
   createNeonVaultStore,
-  createInMemoryVaultStore
+  createPostgresVaultStore,
+  createSecretCipher,
+  createVault,
+  createVersionedSecretCipher,
+  rotateVaultKey,
+  vaultEntriesTable
 };
 
-//# debugId=A59F5C5C4E886DF264756E2164756E21
+//# debugId=D8BF29DF60A0D94B64756E2164756E21
 //# sourceMappingURL=index.js.map