@shipfox/api-runners 2.0.0

package/dist/db/schema/ephemeral-registration-tokens.d.ts

@@ -0,0 +1,199 @@
+import type { EphemeralRegistrationToken } from '#core/entities/ephemeral-registration-token.js';
+export declare const ephemeralRegistrationTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "ephemeral_registration_tokens";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        provisionerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioner_id";
+            tableName: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        reservationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reservation_id";
+            tableName: "ephemeral_registration_tokens";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provisionedRunnerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioned_runner_id";
+            tableName: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        hashedToken: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hashed_token";
+            tableName: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        prefix: import("drizzle-orm/pg-core").PgColumn<{
+            name: "prefix";
+            tableName: "ephemeral_registration_tokens";
+            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: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        consumedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_at";
+            tableName: "ephemeral_registration_tokens";
+            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;
+        }, {}, {}>;
+        consumedSessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_session_id";
+            tableName: "ephemeral_registration_tokens";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            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: "ephemeral_registration_tokens";
+            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 EphemeralRegistrationTokenDb = typeof ephemeralRegistrationTokens.$inferSelect;
+export type EphemeralRegistrationTokenInsertDb = typeof ephemeralRegistrationTokens.$inferInsert;
+export declare function toEphemeralRegistrationToken(row: EphemeralRegistrationTokenDb): EphemeralRegistrationToken;
+//# sourceMappingURL=ephemeral-registration-tokens.d.ts.map

package/dist/db/schema/ephemeral-registration-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeral-registration-tokens.d.ts","sourceRoot":"","sources":["../../../src/db/schema/ephemeral-registration-tokens.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,0BAA0B,EAAC,MAAM,gDAAgD,CAAC;AAG/F,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BvC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,OAAO,2BAA2B,CAAC,YAAY,CAAC;AAC3F,MAAM,MAAM,kCAAkC,GAAG,OAAO,2BAA2B,CAAC,YAAY,CAAC;AAEjG,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,4BAA4B,GAChC,0BAA0B,CAc5B"}

package/dist/db/schema/ephemeral-registration-tokens.js

@@ -0,0 +1,45 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const ephemeralRegistrationTokens = pgTable('ephemeral_registration_tokens', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    reservationId: uuid('reservation_id'),
+    provisionedRunnerId: text('provisioned_runner_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    consumedAt: timestamp('consumed_at', {
+        withTimezone: true
+    }),
+    consumedSessionId: uuid('consumed_session_id'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_ephemeral_registration_tokens_hashed_token_unique').on(table.hashedToken),
+        index('runners_ephemeral_registration_tokens_reservation_id_idx').on(table.reservationId),
+        index('runners_ephemeral_registration_tokens_active_provisioned_runner_idx').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.consumedAt, table.expiresAt),
+        index('runners_ephemeral_registration_tokens_terminal_idx').on(sql`coalesce(${table.consumedAt}, ${table.expiresAt})`, table.id)
+    ]);
+export function toEphemeralRegistrationToken(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        provisionerId: row.provisionerId,
+        reservationId: row.reservationId,
+        provisionedRunnerId: row.provisionedRunnerId,
+        hashedToken: row.hashedToken,
+        prefix: row.prefix,
+        expiresAt: row.expiresAt,
+        consumedAt: row.consumedAt,
+        consumedSessionId: row.consumedSessionId,
+        createdAt: row.createdAt
+    };
+}
+
+//# sourceMappingURL=ephemeral-registration-tokens.js.map

package/dist/db/schema/ephemeral-registration-tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/ephemeral-registration-tokens.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {EphemeralRegistrationToken} from '#core/entities/ephemeral-registration-token.js';\nimport {pgTable} from './common.js';\n\nexport const ephemeralRegistrationTokens = pgTable(\n  'ephemeral_registration_tokens',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    provisionerId: uuid('provisioner_id').notNull(),\n    reservationId: uuid('reservation_id'),\n    provisionedRunnerId: text('provisioned_runner_id').notNull(),\n    hashedToken: text('hashed_token').notNull(),\n    prefix: text('prefix').notNull(),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    consumedAt: timestamp('consumed_at', {withTimezone: true}),\n    consumedSessionId: uuid('consumed_session_id'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_ephemeral_registration_tokens_hashed_token_unique').on(table.hashedToken),\n    index('runners_ephemeral_registration_tokens_reservation_id_idx').on(table.reservationId),\n    index('runners_ephemeral_registration_tokens_active_provisioned_runner_idx').on(\n      table.workspaceId,\n      table.provisionerId,\n      table.provisionedRunnerId,\n      table.consumedAt,\n      table.expiresAt,\n    ),\n    index('runners_ephemeral_registration_tokens_terminal_idx').on(\n      sql`coalesce(${table.consumedAt}, ${table.expiresAt})`,\n      table.id,\n    ),\n  ],\n);\n\nexport type EphemeralRegistrationTokenDb = typeof ephemeralRegistrationTokens.$inferSelect;\nexport type EphemeralRegistrationTokenInsertDb = typeof ephemeralRegistrationTokens.$inferInsert;\n\nexport function toEphemeralRegistrationToken(\n  row: EphemeralRegistrationTokenDb,\n): EphemeralRegistrationToken {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    provisionerId: row.provisionerId,\n    reservationId: row.reservationId,\n    provisionedRunnerId: row.provisionedRunnerId,\n    hashedToken: row.hashedToken,\n    prefix: row.prefix,\n    expiresAt: row.expiresAt,\n    consumedAt: row.consumedAt,\n    consumedSessionId: row.consumedSessionId,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","text","timestamp","uniqueIndex","uuid","pgTable","ephemeralRegistrationTokens","id","workspaceId","notNull","provisionerId","reservationId","provisionedRunnerId","hashedToken","prefix","expiresAt","withTimezone","consumedAt","consumedSessionId","createdAt","defaultNow","table","on","toEphemeralRegistrationToken","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE9E,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,8BAA8BD,QACzC,iCACA;IACEE,IAAIT;IACJU,aAAaJ,KAAK,gBAAgBK,OAAO;IACzCC,eAAeN,KAAK,kBAAkBK,OAAO;IAC7CE,eAAeP,KAAK;IACpBQ,qBAAqBX,KAAK,yBAAyBQ,OAAO;IAC1DI,aAAaZ,KAAK,gBAAgBQ,OAAO;IACzCK,QAAQb,KAAK,UAAUQ,OAAO;IAC9BM,WAAWb,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGP,OAAO;IAChEQ,YAAYf,UAAU,eAAe;QAACc,cAAc;IAAI;IACxDE,mBAAmBd,KAAK;IACxBe,WAAWjB,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGP,OAAO,GAAGW,UAAU;AAC/E,GACA,CAACC,QAAU;QACTlB,YAAY,6DAA6DmB,EAAE,CAACD,MAAMR,WAAW;QAC7Fb,MAAM,4DAA4DsB,EAAE,CAACD,MAAMV,aAAa;QACxFX,MAAM,uEAAuEsB,EAAE,CAC7ED,MAAMb,WAAW,EACjBa,MAAMX,aAAa,EACnBW,MAAMT,mBAAmB,EACzBS,MAAMJ,UAAU,EAChBI,MAAMN,SAAS;QAEjBf,MAAM,sDAAsDsB,EAAE,CAC5DvB,GAAG,CAAC,SAAS,EAAEsB,MAAMJ,UAAU,CAAC,EAAE,EAAEI,MAAMN,SAAS,CAAC,CAAC,CAAC,EACtDM,MAAMd,EAAE;KAEX,EACD;AAKF,OAAO,SAASgB,6BACdC,GAAiC;IAEjC,OAAO;QACLjB,IAAIiB,IAAIjB,EAAE;QACVC,aAAagB,IAAIhB,WAAW;QAC5BE,eAAec,IAAId,aAAa;QAChCC,eAAea,IAAIb,aAAa;QAChCC,qBAAqBY,IAAIZ,mBAAmB;QAC5CC,aAAaW,IAAIX,WAAW;QAC5BC,QAAQU,IAAIV,MAAM;QAClBC,WAAWS,IAAIT,SAAS;QACxBE,YAAYO,IAAIP,UAAU;QAC1BC,mBAAmBM,IAAIN,iBAAiB;QACxCC,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/schema/manual-registration-tokens.d.ts

@@ -0,0 +1,165 @@
+import type { ManualRegistrationToken } from '#core/entities/manual-registration-token.js';
+export declare const manualRegistrationTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "manual_registration_tokens";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "manual_registration_tokens";
+            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;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "manual_registration_tokens";
+            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: "manual_registration_tokens";
+            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;
+        }, {}, {}>;
+        prefix: import("drizzle-orm/pg-core").PgColumn<{
+            name: "prefix";
+            tableName: "manual_registration_tokens";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "manual_registration_tokens";
+            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;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "manual_registration_tokens";
+            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;
+        }, {}, {}>;
+        revokedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "revoked_at";
+            tableName: "manual_registration_tokens";
+            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: "manual_registration_tokens";
+            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: "manual_registration_tokens";
+            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 ManualRegistrationTokenDb = typeof manualRegistrationTokens.$inferSelect;
+export type ManualRegistrationTokenInsertDb = typeof manualRegistrationTokens.$inferInsert;
+export declare function toManualRegistrationToken(row: ManualRegistrationTokenDb): ManualRegistrationToken;
+//# sourceMappingURL=manual-registration-tokens.d.ts.map

package/dist/db/schema/manual-registration-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manual-registration-tokens.d.ts","sourceRoot":"","sources":["../../../src/db/schema/manual-registration-tokens.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,6CAA6C,CAAC;AAGzF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAC;AACrF,MAAM,MAAM,+BAA+B,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAC;AAE3F,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,yBAAyB,GAAG,uBAAuB,CAYjG"}

package/dist/db/schema/manual-registration-tokens.js

@@ -0,0 +1,40 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const manualRegistrationTokens = pgTable('manual_registration_tokens', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    name: text('name'),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }),
+    revokedAt: timestamp('revoked_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_manual_registration_tokens_hashed_token_unique').on(table.hashedToken),
+        index('runners_manual_registration_tokens_workspace_id_idx').on(table.workspaceId)
+    ]);
+export function toManualRegistrationToken(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        hashedToken: row.hashedToken,
+        prefix: row.prefix,
+        name: row.name,
+        expiresAt: row.expiresAt,
+        revokedAt: row.revokedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=manual-registration-tokens.js.map

package/dist/db/schema/manual-registration-tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/manual-registration-tokens.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {ManualRegistrationToken} from '#core/entities/manual-registration-token.js';\nimport {pgTable} from './common.js';\n\nexport const manualRegistrationTokens = pgTable(\n  'manual_registration_tokens',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    hashedToken: text('hashed_token').notNull(),\n    prefix: text('prefix').notNull(),\n    name: text('name'),\n    expiresAt: timestamp('expires_at', {withTimezone: true}),\n    revokedAt: timestamp('revoked_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_manual_registration_tokens_hashed_token_unique').on(table.hashedToken),\n    index('runners_manual_registration_tokens_workspace_id_idx').on(table.workspaceId),\n  ],\n);\n\nexport type ManualRegistrationTokenDb = typeof manualRegistrationTokens.$inferSelect;\nexport type ManualRegistrationTokenInsertDb = typeof manualRegistrationTokens.$inferInsert;\n\nexport function toManualRegistrationToken(row: ManualRegistrationTokenDb): ManualRegistrationToken {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    hashedToken: row.hashedToken,\n    prefix: row.prefix,\n    name: row.name,\n    expiresAt: row.expiresAt,\n    revokedAt: row.revokedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","manualRegistrationTokens","id","workspaceId","notNull","hashedToken","prefix","name","expiresAt","withTimezone","revokedAt","createdAt","defaultNow","updatedAt","table","on","toManualRegistrationToken","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;AAEpC,OAAO,MAAMC,2BAA2BD,QACtC,8BACA;IACEE,IAAIR;IACJS,aAAaJ,KAAK,gBAAgBK,OAAO;IACzCC,aAAaT,KAAK,gBAAgBQ,OAAO;IACzCE,QAAQV,KAAK,UAAUQ,OAAO;IAC9BG,MAAMX,KAAK;IACXY,WAAWX,UAAU,cAAc;QAACY,cAAc;IAAI;IACtDC,WAAWb,UAAU,cAAc;QAACY,cAAc;IAAI;IACtDE,WAAWd,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGQ,UAAU;IAC7EC,WAAWhB,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGQ,UAAU;AAC/E,GACA,CAACE,QAAU;QACThB,YAAY,0DAA0DiB,EAAE,CAACD,MAAMT,WAAW;QAC1FV,MAAM,uDAAuDoB,EAAE,CAACD,MAAMX,WAAW;KAClF,EACD;AAKF,OAAO,SAASa,0BAA0BC,GAA8B;IACtE,OAAO;QACLf,IAAIe,IAAIf,EAAE;QACVC,aAAac,IAAId,WAAW;QAC5BE,aAAaY,IAAIZ,WAAW;QAC5BC,QAAQW,IAAIX,MAAM;QAClBC,MAAMU,IAAIV,IAAI;QACdC,WAAWS,IAAIT,SAAS;QACxBE,WAAWO,IAAIP,SAAS;QACxBC,WAAWM,IAAIN,SAAS;QACxBE,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

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

@@ -0,0 +1,195 @@
+export declare const runnersOutbox: 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,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}