@shipfox/api-runners 4.0.0 → 6.0.0

package/dist/db/schema/provisioner-tokens.js

@@ -1,9 +1,15 @@
 import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
-import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+import { check, index, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { pgTable } from './common.js';
+export const provisionerScopeEnum = pgEnum('runners_provisioner_scope', [
+    'workspace',
+    'installation'
+]);
 export const provisionerTokens = pgTable('provisioner_tokens', {
     id: uuidv7PrimaryKey(),
-    workspaceId: uuid('workspace_id').notNull(),
+    scope: provisionerScopeEnum('scope').notNull(),
+    workspaceId: uuid('workspace_id'),
     hashedToken: text('hashed_token').notNull(),
     prefix: text('prefix').notNull(),
     name: text('name'),
@@ -26,11 +32,31 @@ export const provisionerTokens = pgTable('provisioner_tokens', {
     }).notNull().defaultNow()
 }, (table)=>[
         uniqueIndex('runners_provisioner_tokens_hashed_token_unique').on(table.hashedToken),
-        index('runners_provisioner_tokens_workspace_last_seen_idx').on(table.workspaceId, table.lastSeenAt.desc(), table.id.desc())
+        index('runners_provisioner_tokens_workspace_last_seen_idx').on(table.workspaceId, table.lastSeenAt.desc(), table.id.desc()),
+        check('runners_provisioner_tokens_scope_workspace_ck', sql`(scope = 'workspace' AND workspace_id IS NOT NULL) OR (scope = 'installation' AND workspace_id IS NULL)`)
     ]);
 export function toProvisionerToken(row) {
+    if (row.scope === 'installation') {
+        return {
+            id: row.id,
+            scope: 'installation',
+            workspaceId: null,
+            hashedToken: row.hashedToken,
+            prefix: row.prefix,
+            name: row.name,
+            createdByUserId: row.createdByUserId,
+            revokedByUserId: row.revokedByUserId,
+            expiresAt: row.expiresAt,
+            revokedAt: row.revokedAt,
+            lastSeenAt: row.lastSeenAt,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt
+        };
+    }
+    if (!row.workspaceId) throw new Error('Workspace provisioner token has no workspace');
     return {
         id: row.id,
+        scope: 'workspace',
         workspaceId: row.workspaceId,
         hashedToken: row.hashedToken,
         prefix: row.prefix,

package/dist/db/schema/provisioner-tokens.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/db/schema/provisioner-tokens.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {ProvisionerToken} from '#core/entities/provisioner-token.js';\nimport {pgTable} from './common.js';\n\nexport const provisionerTokens = pgTable(\n  'provisioner_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    createdByUserId: uuid('created_by_user_id').notNull(),\n    revokedByUserId: uuid('revoked_by_user_id'),\n    expiresAt: timestamp('expires_at', {withTimezone: true}),\n    revokedAt: timestamp('revoked_at', {withTimezone: true}),\n    lastSeenAt: timestamp('last_seen_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_provisioner_tokens_hashed_token_unique').on(table.hashedToken),\n    index('runners_provisioner_tokens_workspace_last_seen_idx').on(\n      table.workspaceId,\n      table.lastSeenAt.desc(),\n      table.id.desc(),\n    ),\n  ],\n);\n\nexport type ProvisionerTokenDb = typeof provisionerTokens.$inferSelect;\nexport type ProvisionerTokenInsertDb = typeof provisionerTokens.$inferInsert;\n\nexport function toProvisionerToken(row: ProvisionerTokenDb): ProvisionerToken {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    hashedToken: row.hashedToken,\n    prefix: row.prefix,\n    name: row.name,\n    createdByUserId: row.createdByUserId,\n    revokedByUserId: row.revokedByUserId,\n    expiresAt: row.expiresAt,\n    revokedAt: row.revokedAt,\n    lastSeenAt: row.lastSeenAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","provisionerTokens","id","workspaceId","notNull","hashedToken","prefix","name","createdByUserId","revokedByUserId","expiresAt","withTimezone","revokedAt","lastSeenAt","createdAt","defaultNow","updatedAt","table","on","desc","toProvisionerToken","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,oBAAoBD,QAC/B,sBACA;IACEE,IAAIR;IACJS,aAAaJ,KAAK,gBAAgBK,OAAO;IACzCC,aAAaT,KAAK,gBAAgBQ,OAAO;IACzCE,QAAQV,KAAK,UAAUQ,OAAO;IAC9BG,MAAMX,KAAK;IACXY,iBAAiBT,KAAK,sBAAsBK,OAAO;IACnDK,iBAAiBV,KAAK;IACtBW,WAAWb,UAAU,cAAc;QAACc,cAAc;IAAI;IACtDC,WAAWf,UAAU,cAAc;QAACc,cAAc;IAAI;IACtDE,YAAYhB,UAAU,gBAAgB;QAACc,cAAc;IAAI;IACzDG,WAAWjB,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGP,OAAO,GAAGW,UAAU;IAC7EC,WAAWnB,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGP,OAAO,GAAGW,UAAU;AAC/E,GACA,CAACE,QAAU;QACTnB,YAAY,kDAAkDoB,EAAE,CAACD,MAAMZ,WAAW;QAClFV,MAAM,sDAAsDuB,EAAE,CAC5DD,MAAMd,WAAW,EACjBc,MAAMJ,UAAU,CAACM,IAAI,IACrBF,MAAMf,EAAE,CAACiB,IAAI;KAEhB,EACD;AAKF,OAAO,SAASC,mBAAmBC,GAAuB;IACxD,OAAO;QACLnB,IAAImB,IAAInB,EAAE;QACVC,aAAakB,IAAIlB,WAAW;QAC5BE,aAAagB,IAAIhB,WAAW;QAC5BC,QAAQe,IAAIf,MAAM;QAClBC,MAAMc,IAAId,IAAI;QACdC,iBAAiBa,IAAIb,eAAe;QACpCC,iBAAiBY,IAAIZ,eAAe;QACpCC,WAAWW,IAAIX,SAAS;QACxBE,WAAWS,IAAIT,SAAS;QACxBC,YAAYQ,IAAIR,UAAU;QAC1BC,WAAWO,IAAIP,SAAS;QACxBE,WAAWK,IAAIL,SAAS;IAC1B;AACF"}
+{"version":3,"sources":["../../../src/db/schema/provisioner-tokens.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {check, index, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {ProvisionerToken} from '#core/entities/provisioner-token.js';\nimport {pgTable} from './common.js';\n\nexport const provisionerScopeEnum = pgEnum('runners_provisioner_scope', [\n  'workspace',\n  'installation',\n]);\n\nexport const provisionerTokens = pgTable(\n  'provisioner_tokens',\n  {\n    id: uuidv7PrimaryKey(),\n    scope: provisionerScopeEnum('scope').notNull(),\n    workspaceId: uuid('workspace_id'),\n    hashedToken: text('hashed_token').notNull(),\n    prefix: text('prefix').notNull(),\n    name: text('name'),\n    createdByUserId: uuid('created_by_user_id').notNull(),\n    revokedByUserId: uuid('revoked_by_user_id'),\n    expiresAt: timestamp('expires_at', {withTimezone: true}),\n    revokedAt: timestamp('revoked_at', {withTimezone: true}),\n    lastSeenAt: timestamp('last_seen_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_provisioner_tokens_hashed_token_unique').on(table.hashedToken),\n    index('runners_provisioner_tokens_workspace_last_seen_idx').on(\n      table.workspaceId,\n      table.lastSeenAt.desc(),\n      table.id.desc(),\n    ),\n    check(\n      'runners_provisioner_tokens_scope_workspace_ck',\n      sql`(scope = 'workspace' AND workspace_id IS NOT NULL) OR (scope = 'installation' AND workspace_id IS NULL)`,\n    ),\n  ],\n);\n\nexport type ProvisionerTokenDb = typeof provisionerTokens.$inferSelect;\nexport type ProvisionerTokenInsertDb = typeof provisionerTokens.$inferInsert;\n\nexport function toProvisionerToken(row: ProvisionerTokenDb): ProvisionerToken {\n  if (row.scope === 'installation') {\n    return {\n      id: row.id,\n      scope: 'installation',\n      workspaceId: null,\n      hashedToken: row.hashedToken,\n      prefix: row.prefix,\n      name: row.name,\n      createdByUserId: row.createdByUserId,\n      revokedByUserId: row.revokedByUserId,\n      expiresAt: row.expiresAt,\n      revokedAt: row.revokedAt,\n      lastSeenAt: row.lastSeenAt,\n      createdAt: row.createdAt,\n      updatedAt: row.updatedAt,\n    };\n  }\n\n  if (!row.workspaceId) throw new Error('Workspace provisioner token has no workspace');\n  return {\n    id: row.id,\n    scope: 'workspace',\n    workspaceId: row.workspaceId,\n    hashedToken: row.hashedToken,\n    prefix: row.prefix,\n    name: row.name,\n    createdByUserId: row.createdByUserId,\n    revokedByUserId: row.revokedByUserId,\n    expiresAt: row.expiresAt,\n    revokedAt: row.revokedAt,\n    lastSeenAt: row.lastSeenAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","check","index","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","provisionerScopeEnum","provisionerTokens","id","scope","notNull","workspaceId","hashedToken","prefix","name","createdByUserId","revokedByUserId","expiresAt","withTimezone","revokedAt","lastSeenAt","createdAt","defaultNow","updatedAt","table","on","desc","toProvisionerToken","row","Error"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE7F,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,uBAAuBN,OAAO,6BAA6B;IACtE;IACA;CACD,EAAE;AAEH,OAAO,MAAMO,oBAAoBF,QAC/B,sBACA;IACEG,IAAIZ;IACJa,OAAOH,qBAAqB,SAASI,OAAO;IAC5CC,aAAaP,KAAK;IAClBQ,aAAaX,KAAK,gBAAgBS,OAAO;IACzCG,QAAQZ,KAAK,UAAUS,OAAO;IAC9BI,MAAMb,KAAK;IACXc,iBAAiBX,KAAK,sBAAsBM,OAAO;IACnDM,iBAAiBZ,KAAK;IACtBa,WAAWf,UAAU,cAAc;QAACgB,cAAc;IAAI;IACtDC,WAAWjB,UAAU,cAAc;QAACgB,cAAc;IAAI;IACtDE,YAAYlB,UAAU,gBAAgB;QAACgB,cAAc;IAAI;IACzDG,WAAWnB,UAAU,cAAc;QAACgB,cAAc;IAAI,GAAGR,OAAO,GAAGY,UAAU;IAC7EC,WAAWrB,UAAU,cAAc;QAACgB,cAAc;IAAI,GAAGR,OAAO,GAAGY,UAAU;AAC/E,GACA,CAACE,QAAU;QACTrB,YAAY,kDAAkDsB,EAAE,CAACD,MAAMZ,WAAW;QAClFb,MAAM,sDAAsD0B,EAAE,CAC5DD,MAAMb,WAAW,EACjBa,MAAMJ,UAAU,CAACM,IAAI,IACrBF,MAAMhB,EAAE,CAACkB,IAAI;QAEf5B,MACE,iDACAD,GAAG,CAAC,uGAAuG,CAAC;KAE/G,EACD;AAKF,OAAO,SAAS8B,mBAAmBC,GAAuB;IACxD,IAAIA,IAAInB,KAAK,KAAK,gBAAgB;QAChC,OAAO;YACLD,IAAIoB,IAAIpB,EAAE;YACVC,OAAO;YACPE,aAAa;YACbC,aAAagB,IAAIhB,WAAW;YAC5BC,QAAQe,IAAIf,MAAM;YAClBC,MAAMc,IAAId,IAAI;YACdC,iBAAiBa,IAAIb,eAAe;YACpCC,iBAAiBY,IAAIZ,eAAe;YACpCC,WAAWW,IAAIX,SAAS;YACxBE,WAAWS,IAAIT,SAAS;YACxBC,YAAYQ,IAAIR,UAAU;YAC1BC,WAAWO,IAAIP,SAAS;YACxBE,WAAWK,IAAIL,SAAS;QAC1B;IACF;IAEA,IAAI,CAACK,IAAIjB,WAAW,EAAE,MAAM,IAAIkB,MAAM;IACtC,OAAO;QACLrB,IAAIoB,IAAIpB,EAAE;QACVC,OAAO;QACPE,aAAaiB,IAAIjB,WAAW;QAC5BC,aAAagB,IAAIhB,WAAW;QAC5BC,QAAQe,IAAIf,MAAM;QAClBC,MAAMc,IAAId,IAAI;QACdC,iBAAiBa,IAAIb,eAAe;QACpCC,iBAAiBY,IAAIZ,eAAe;QACpCC,WAAWW,IAAIX,SAAS;QACxBE,WAAWS,IAAIT,SAAS;QACxBC,YAAYQ,IAAIR,UAAU;QAC1BC,WAAWO,IAAIP,SAAS;QACxBE,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/schema/runner-activation-tokens.d.ts

@@ -0,0 +1,161 @@
+export declare const runnerActivationTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "runner_activation_tokens";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "runner_activation_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;
+        }, {}, {}>;
+        runnerInstanceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner_instance_id";
+            tableName: "runner_activation_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: "runner_activation_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: "runner_activation_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: "runner_activation_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: "runner_activation_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: "runner_activation_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: "runner_activation_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: "runner_activation_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";
+}>;
+//# sourceMappingURL=runner-activation-tokens.d.ts.map

package/dist/db/schema/runner-activation-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-activation-tokens.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-activation-tokens.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC"}

package/dist/db/schema/runner-activation-tokens.js

@@ -0,0 +1,27 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const runnerActivationTokens = pgTable('runner_activation_tokens', {
+    id: uuidv7PrimaryKey(),
+    runnerInstanceId: uuid('runner_instance_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    consumedAt: timestamp('consumed_at', {
+        withTimezone: true
+    }),
+    revokedAt: timestamp('revoked_at', {
+        withTimezone: true
+    }),
+    consumedSessionId: uuid('consumed_session_id'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_runner_activation_tokens_hashed_token_unique').on(table.hashedToken),
+        index('runners_runner_activation_tokens_runner_instance_idx').on(table.runnerInstanceId)
+    ]);
+
+//# sourceMappingURL=runner-activation-tokens.js.map

package/dist/db/schema/runner-activation-tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/runner-activation-tokens.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport {pgTable} from './common.js';\n\nexport const runnerActivationTokens = pgTable(\n  'runner_activation_tokens',\n  {\n    id: uuidv7PrimaryKey(),\n    runnerInstanceId: uuid('runner_instance_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    revokedAt: timestamp('revoked_at', {withTimezone: true}),\n    consumedSessionId: uuid('consumed_session_id'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_runner_activation_tokens_hashed_token_unique').on(table.hashedToken),\n    index('runners_runner_activation_tokens_runner_instance_idx').on(table.runnerInstanceId),\n  ],\n);\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","runnerActivationTokens","id","runnerInstanceId","notNull","hashedToken","prefix","expiresAt","withTimezone","consumedAt","revokedAt","consumedSessionId","createdAt","defaultNow","table","on"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAC9E,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,yBAAyBD,QACpC,4BACA;IACEE,IAAIR;IACJS,kBAAkBJ,KAAK,sBAAsBK,OAAO;IACpDC,aAAaT,KAAK,gBAAgBQ,OAAO;IACzCE,QAAQV,KAAK,UAAUQ,OAAO;IAC9BG,WAAWV,UAAU,cAAc;QAACW,cAAc;IAAI,GAAGJ,OAAO;IAChEK,YAAYZ,UAAU,eAAe;QAACW,cAAc;IAAI;IACxDE,WAAWb,UAAU,cAAc;QAACW,cAAc;IAAI;IACtDG,mBAAmBZ,KAAK;IACxBa,WAAWf,UAAU,cAAc;QAACW,cAAc;IAAI,GAAGJ,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACC,QAAU;QACThB,YAAY,wDAAwDiB,EAAE,CAACD,MAAMT,WAAW;QACxFV,MAAM,wDAAwDoB,EAAE,CAACD,MAAMX,gBAAgB;KACxF,EACD"}

package/dist/db/schema/runner-control-sessions.d.ts

@@ -0,0 +1,338 @@
+export declare const runnerBootstrapTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "runner_bootstrap_tokens";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "runner_bootstrap_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;
+        }, {}, {}>;
+        runnerInstanceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner_instance_id";
+            tableName: "runner_bootstrap_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: "runner_bootstrap_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: "runner_bootstrap_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: "runner_bootstrap_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: "runner_bootstrap_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: "runner_bootstrap_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: "runner_bootstrap_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: "runner_bootstrap_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 declare const runnerControlSessions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "runner_control_sessions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "runner_control_sessions";
+            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;
+        }, {}, {}>;
+        runnerInstanceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner_instance_id";
+            tableName: "runner_control_sessions";
+            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: "runner_control_sessions";
+            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: "runner_control_sessions";
+            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: "runner_control_sessions";
+            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: "runner_control_sessions";
+            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;
+        }, {}, {}>;
+        lastSeenAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_seen_at";
+            tableName: "runner_control_sessions";
+            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;
+        }, {}, {}>;
+        closedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "closed_at";
+            tableName: "runner_control_sessions";
+            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;
+        }, {}, {}>;
+        closeReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "close_reason";
+            tableName: "runner_control_sessions";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "runner_control_sessions";
+            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";
+}>;
+//# sourceMappingURL=runner-control-sessions.d.ts.map

package/dist/db/schema/runner-control-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-control-sessions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-control-sessions.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBjC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBjC,CAAC"}

package/dist/db/schema/runner-control-sessions.js

@@ -0,0 +1,52 @@
+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 runnerBootstrapTokens = pgTable('runner_bootstrap_tokens', {
+    id: uuidv7PrimaryKey(),
+    runnerInstanceId: uuid('runner_instance_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    consumedAt: timestamp('consumed_at', {
+        withTimezone: true
+    }),
+    revokedAt: timestamp('revoked_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_runner_bootstrap_tokens_hashed_token_unique').on(table.hashedToken),
+        index('runners_runner_bootstrap_tokens_runner_instance_idx').on(table.runnerInstanceId)
+    ]);
+export const runnerControlSessions = pgTable('runner_control_sessions', {
+    id: uuidv7PrimaryKey(),
+    runnerInstanceId: uuid('runner_instance_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    lastSeenAt: timestamp('last_seen_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    closedAt: timestamp('closed_at', {
+        withTimezone: true
+    }),
+    closeReason: text('close_reason'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_runner_control_sessions_hashed_token_unique').on(table.hashedToken),
+        uniqueIndex('runners_runner_control_sessions_active_runner_instance_unique').on(table.runnerInstanceId).where(sql`"closed_at" is null`),
+        index('runners_runner_control_sessions_runner_instance_idx').on(table.runnerInstanceId)
+    ]);
+
+//# sourceMappingURL=runner-control-sessions.js.map