@shipfox/api-auth 2.0.0

package/dist/db/schema/email-verifications.d.ts

@@ -0,0 +1,114 @@
+import type { EmailVerification } from '#core/entities/email-verification.js';
+export declare const emailVerifications: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "email_verifications";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "email_verifications";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "email_verifications";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hashedToken: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hashed_token";
+            tableName: "email_verifications";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "email_verifications";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        usedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "used_at";
+            tableName: "email_verifications";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "email_verifications";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type EmailVerificationDb = typeof emailVerifications.$inferSelect;
+export type EmailVerificationCreateDb = typeof emailVerifications.$inferInsert;
+export declare function toEmailVerification(row: EmailVerificationDb): EmailVerification;
+//# sourceMappingURL=email-verifications.d.ts.map

package/dist/db/schema/email-verifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-verifications.d.ts","sourceRoot":"","sources":["../../../src/db/schema/email-verifications.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sCAAsC,CAAC;AAI5E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AAE/E,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,CAS/E"}

package/dist/db/schema/email-verifications.js

@@ -0,0 +1,35 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { users } from './users.js';
+export const emailVerifications = pgTable('email_verifications', {
+    id: uuidv7PrimaryKey(),
+    userId: uuid('user_id').notNull().references(()=>users.id, {
+        onDelete: 'cascade'
+    }),
+    hashedToken: text('hashed_token').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    usedAt: timestamp('used_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('auth_email_verifications_hashed_token_unique').on(table.hashedToken),
+        index('auth_email_verifications_user_id_idx').on(table.userId)
+    ]);
+export function toEmailVerification(row) {
+    return {
+        id: row.id,
+        userId: row.userId,
+        hashedToken: row.hashedToken,
+        expiresAt: row.expiresAt,
+        usedAt: row.usedAt,
+        createdAt: row.createdAt
+    };
+}
+
+//# sourceMappingURL=email-verifications.js.map

package/dist/db/schema/email-verifications.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/email-verifications.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {EmailVerification} from '#core/entities/email-verification.js';\nimport {pgTable} from './common.js';\nimport {users} from './users.js';\n\nexport const emailVerifications = pgTable(\n  'email_verifications',\n  {\n    id: uuidv7PrimaryKey(),\n    userId: uuid('user_id')\n      .notNull()\n      .references(() => users.id, {onDelete: 'cascade'}),\n    hashedToken: text('hashed_token').notNull(),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    usedAt: timestamp('used_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('auth_email_verifications_hashed_token_unique').on(table.hashedToken),\n    index('auth_email_verifications_user_id_idx').on(table.userId),\n  ],\n);\n\nexport type EmailVerificationDb = typeof emailVerifications.$inferSelect;\nexport type EmailVerificationCreateDb = typeof emailVerifications.$inferInsert;\n\nexport function toEmailVerification(row: EmailVerificationDb): EmailVerification {\n  return {\n    id: row.id,\n    userId: row.userId,\n    hashedToken: row.hashedToken,\n    expiresAt: row.expiresAt,\n    usedAt: row.usedAt,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","users","emailVerifications","id","userId","notNull","references","onDelete","hashedToken","expiresAt","withTimezone","usedAt","createdAt","defaultNow","table","on","toEmailVerification","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE9E,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,KAAK,QAAO,aAAa;AAEjC,OAAO,MAAMC,qBAAqBF,QAChC,uBACA;IACEG,IAAIT;IACJU,QAAQL,KAAK,WACVM,OAAO,GACPC,UAAU,CAAC,IAAML,MAAME,EAAE,EAAE;QAACI,UAAU;IAAS;IAClDC,aAAaZ,KAAK,gBAAgBS,OAAO;IACzCI,WAAWZ,UAAU,cAAc;QAACa,cAAc;IAAI,GAAGL,OAAO;IAChEM,QAAQd,UAAU,WAAW;QAACa,cAAc;IAAI;IAChDE,WAAWf,UAAU,cAAc;QAACa,cAAc;IAAI,GAAGL,OAAO,GAAGQ,UAAU;AAC/E,GACA,CAACC,QAAU;QACThB,YAAY,gDAAgDiB,EAAE,CAACD,MAAMN,WAAW;QAChFb,MAAM,wCAAwCoB,EAAE,CAACD,MAAMV,MAAM;KAC9D,EACD;AAKF,OAAO,SAASY,oBAAoBC,GAAwB;IAC1D,OAAO;QACLd,IAAIc,IAAId,EAAE;QACVC,QAAQa,IAAIb,MAAM;QAClBI,aAAaS,IAAIT,WAAW;QAC5BC,WAAWQ,IAAIR,SAAS;QACxBE,QAAQM,IAAIN,MAAM;QAClBC,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/schema/outbox.d.ts

@@ -0,0 +1,195 @@
+export declare const authOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orderingKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ordering_key";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatched_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatch_attempts";
+            tableName: "outbox";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextDispatchAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_dispatch_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_error";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchFailedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_failed_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deadLetteredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dead_lettered_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/db/schema/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/db/schema/outbox.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}

package/dist/db/schema/outbox.js

@@ -0,0 +1,5 @@
+import { createOutboxTable } from '@shipfox/node-outbox';
+import { pgTable } from './common.js';
+export const authOutbox = createOutboxTable(pgTable);
+
+//# sourceMappingURL=outbox.js.map

package/dist/db/schema/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/outbox.ts"],"sourcesContent":["import {createOutboxTable} from '@shipfox/node-outbox';\nimport {pgTable} from './common.js';\n\nexport const authOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","authOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,aAAaF,kBAAkBC,SAAS"}

package/dist/db/schema/password-resets.d.ts

@@ -0,0 +1,114 @@
+import type { PasswordReset } from '#core/entities/password-reset.js';
+export declare const passwordResets: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "password_resets";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "password_resets";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "password_resets";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hashedToken: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hashed_token";
+            tableName: "password_resets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "password_resets";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        usedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "used_at";
+            tableName: "password_resets";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "password_resets";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type PasswordResetDb = typeof passwordResets.$inferSelect;
+export type PasswordResetCreateDb = typeof passwordResets.$inferInsert;
+export declare function toPasswordReset(row: PasswordResetDb): PasswordReset;
+//# sourceMappingURL=password-resets.d.ts.map

package/dist/db/schema/password-resets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-resets.d.ts","sourceRoot":"","sources":["../../../src/db/schema/password-resets.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAIpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,qBAAqB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAEvE,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CASnE"}

package/dist/db/schema/password-resets.js

@@ -0,0 +1,35 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { users } from './users.js';
+export const passwordResets = pgTable('password_resets', {
+    id: uuidv7PrimaryKey(),
+    userId: uuid('user_id').notNull().references(()=>users.id, {
+        onDelete: 'cascade'
+    }),
+    hashedToken: text('hashed_token').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    usedAt: timestamp('used_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('auth_password_resets_hashed_token_unique').on(table.hashedToken),
+        index('auth_password_resets_user_id_idx').on(table.userId)
+    ]);
+export function toPasswordReset(row) {
+    return {
+        id: row.id,
+        userId: row.userId,
+        hashedToken: row.hashedToken,
+        expiresAt: row.expiresAt,
+        usedAt: row.usedAt,
+        createdAt: row.createdAt
+    };
+}
+
+//# sourceMappingURL=password-resets.js.map

package/dist/db/schema/password-resets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/password-resets.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {PasswordReset} from '#core/entities/password-reset.js';\nimport {pgTable} from './common.js';\nimport {users} from './users.js';\n\nexport const passwordResets = pgTable(\n  'password_resets',\n  {\n    id: uuidv7PrimaryKey(),\n    userId: uuid('user_id')\n      .notNull()\n      .references(() => users.id, {onDelete: 'cascade'}),\n    hashedToken: text('hashed_token').notNull(),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    usedAt: timestamp('used_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('auth_password_resets_hashed_token_unique').on(table.hashedToken),\n    index('auth_password_resets_user_id_idx').on(table.userId),\n  ],\n);\n\nexport type PasswordResetDb = typeof passwordResets.$inferSelect;\nexport type PasswordResetCreateDb = typeof passwordResets.$inferInsert;\n\nexport function toPasswordReset(row: PasswordResetDb): PasswordReset {\n  return {\n    id: row.id,\n    userId: row.userId,\n    hashedToken: row.hashedToken,\n    expiresAt: row.expiresAt,\n    usedAt: row.usedAt,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","users","passwordResets","id","userId","notNull","references","onDelete","hashedToken","expiresAt","withTimezone","usedAt","createdAt","defaultNow","table","on","toPasswordReset","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE9E,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,KAAK,QAAO,aAAa;AAEjC,OAAO,MAAMC,iBAAiBF,QAC5B,mBACA;IACEG,IAAIT;IACJU,QAAQL,KAAK,WACVM,OAAO,GACPC,UAAU,CAAC,IAAML,MAAME,EAAE,EAAE;QAACI,UAAU;IAAS;IAClDC,aAAaZ,KAAK,gBAAgBS,OAAO;IACzCI,WAAWZ,UAAU,cAAc;QAACa,cAAc;IAAI,GAAGL,OAAO;IAChEM,QAAQd,UAAU,WAAW;QAACa,cAAc;IAAI;IAChDE,WAAWf,UAAU,cAAc;QAACa,cAAc;IAAI,GAAGL,OAAO,GAAGQ,UAAU;AAC/E,GACA,CAACC,QAAU;QACThB,YAAY,4CAA4CiB,EAAE,CAACD,MAAMN,WAAW;QAC5Eb,MAAM,oCAAoCoB,EAAE,CAACD,MAAMV,MAAM;KAC1D,EACD;AAKF,OAAO,SAASY,gBAAgBC,GAAoB;IAClD,OAAO;QACLd,IAAIc,IAAId,EAAE;QACVC,QAAQa,IAAIb,MAAM;QAClBI,aAAaS,IAAIT,WAAW;QAC5BC,WAAWQ,IAAIR,SAAS;QACxBE,QAAQM,IAAIN,MAAM;QAClBC,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/schema/rate-limits.d.ts

@@ -0,0 +1,145 @@
+export declare const authRateLimits: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "rate_limits";
+    schema: undefined;
+    columns: {
+        action: import("drizzle-orm/pg-core").PgColumn<{
+            name: "action";
+            tableName: "rate_limits";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "rate_limits";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        identifierHmac: import("drizzle-orm/pg-core").PgColumn<{
+            name: "identifier_hmac";
+            tableName: "rate_limits";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        windowStart: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_start";
+            tableName: "rate_limits";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        count: import("drizzle-orm/pg-core").PgColumn<{
+            name: "count";
+            tableName: "rate_limits";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "rate_limits";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "rate_limits";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "rate_limits";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type AuthRateLimitDb = typeof authRateLimits.$inferSelect;
+//# sourceMappingURL=rate-limits.d.ts.map

package/dist/db/schema/rate-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limits.d.ts","sourceRoot":"","sources":["../../../src/db/schema/rate-limits.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC"}