@shipfox/api-runners 2.0.0

package/dist/db/schema/provisioned-runners.js

@@ -0,0 +1,83 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { index, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const provisionedRunnerStateEnum = pgEnum('runners_provisioned_runner_state', [
+    'starting',
+    'running',
+    'stopping',
+    'stopped',
+    'failed',
+    'terminated'
+]);
+export const provisionedRunners = pgTable('provisioned_runners', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    provisionedRunnerId: text('provisioned_runner_id').notNull(),
+    reservationId: uuid('reservation_id'),
+    templateKey: text('template_key'),
+    labels: text('labels').array().notNull(),
+    state: provisionedRunnerStateEnum('state').notNull(),
+    reason: text('reason'),
+    runnerSessionId: uuid('runner_session_id'),
+    providerKind: text('provider_kind'),
+    reportedAt: timestamp('reported_at', {
+        withTimezone: true
+    }).notNull(),
+    startedAt: timestamp('started_at', {
+        withTimezone: true
+    }),
+    stoppingAt: timestamp('stopping_at', {
+        withTimezone: true
+    }),
+    stoppedAt: timestamp('stopped_at', {
+        withTimezone: true
+    }),
+    failedAt: timestamp('failed_at', {
+        withTimezone: true
+    }),
+    terminatedAt: timestamp('terminated_at', {
+        withTimezone: true
+    }),
+    reservationReleasedAt: timestamp('reservation_released_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_provisioned_runners_workspace_provisioner_runner_unique').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId),
+        index('runners_provisioned_runners_workspace_state_updated_idx').on(table.workspaceId, table.state, table.updatedAt),
+        index('runners_provisioned_runners_stale_reaper_idx').on(table.state, table.updatedAt, table.reportedAt, table.workspaceId),
+        index('runners_provisioned_runners_active_template_counts_idx').on(table.workspaceId, table.provisionerId, table.state, table.templateKey).where(sql`"state" in ('starting', 'running') and "template_key" is not null`)
+    ]);
+export function toProvisionedRunner(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        provisionerId: row.provisionerId,
+        provisionedRunnerId: row.provisionedRunnerId,
+        reservationId: row.reservationId,
+        templateKey: row.templateKey,
+        labels: row.labels,
+        state: row.state,
+        reason: row.reason,
+        runnerSessionId: row.runnerSessionId,
+        providerKind: row.providerKind,
+        reportedAt: row.reportedAt,
+        startedAt: row.startedAt,
+        stoppingAt: row.stoppingAt,
+        stoppedAt: row.stoppedAt,
+        failedAt: row.failedAt,
+        terminatedAt: row.terminatedAt,
+        reservationReleasedAt: row.reservationReleasedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=provisioned-runners.js.map

package/dist/db/schema/provisioned-runners.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/provisioned-runners.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {ProvisionedRunner} from '#core/entities/provisioned-runner.js';\nimport {pgTable} from './common.js';\n\nexport const provisionedRunnerStateEnum = pgEnum('runners_provisioned_runner_state', [\n  'starting',\n  'running',\n  'stopping',\n  'stopped',\n  'failed',\n  'terminated',\n]);\n\nexport const provisionedRunners = pgTable(\n  'provisioned_runners',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    provisionerId: uuid('provisioner_id').notNull(),\n    provisionedRunnerId: text('provisioned_runner_id').notNull(),\n    reservationId: uuid('reservation_id'),\n    templateKey: text('template_key'),\n    labels: text('labels').array().notNull(),\n    state: provisionedRunnerStateEnum('state').notNull(),\n    reason: text('reason'),\n    runnerSessionId: uuid('runner_session_id'),\n    providerKind: text('provider_kind'),\n    reportedAt: timestamp('reported_at', {withTimezone: true}).notNull(),\n    startedAt: timestamp('started_at', {withTimezone: true}),\n    stoppingAt: timestamp('stopping_at', {withTimezone: true}),\n    stoppedAt: timestamp('stopped_at', {withTimezone: true}),\n    failedAt: timestamp('failed_at', {withTimezone: true}),\n    terminatedAt: timestamp('terminated_at', {withTimezone: true}),\n    reservationReleasedAt: timestamp('reservation_released_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_provisioned_runners_workspace_provisioner_runner_unique').on(\n      table.workspaceId,\n      table.provisionerId,\n      table.provisionedRunnerId,\n    ),\n    index('runners_provisioned_runners_workspace_state_updated_idx').on(\n      table.workspaceId,\n      table.state,\n      table.updatedAt,\n    ),\n    index('runners_provisioned_runners_stale_reaper_idx').on(\n      table.state,\n      table.updatedAt,\n      table.reportedAt,\n      table.workspaceId,\n    ),\n    index('runners_provisioned_runners_active_template_counts_idx')\n      .on(table.workspaceId, table.provisionerId, table.state, table.templateKey)\n      .where(sql`\"state\" in ('starting', 'running') and \"template_key\" is not null`),\n  ],\n);\n\nexport type ProvisionedRunnerDb = typeof provisionedRunners.$inferSelect;\nexport type ProvisionedRunnerInsertDb = typeof provisionedRunners.$inferInsert;\n\nexport function toProvisionedRunner(row: ProvisionedRunnerDb): ProvisionedRunner {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    provisionerId: row.provisionerId,\n    provisionedRunnerId: row.provisionedRunnerId,\n    reservationId: row.reservationId,\n    templateKey: row.templateKey,\n    labels: row.labels,\n    state: row.state,\n    reason: row.reason,\n    runnerSessionId: row.runnerSessionId,\n    providerKind: row.providerKind,\n    reportedAt: row.reportedAt,\n    startedAt: row.startedAt,\n    stoppingAt: row.stoppingAt,\n    stoppedAt: row.stoppedAt,\n    failedAt: row.failedAt,\n    terminatedAt: row.terminatedAt,\n    reservationReleasedAt: row.reservationReleasedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","provisionedRunnerStateEnum","provisionedRunners","id","workspaceId","notNull","provisionerId","provisionedRunnerId","reservationId","templateKey","labels","array","state","reason","runnerSessionId","providerKind","reportedAt","withTimezone","startedAt","stoppingAt","stoppedAt","failedAt","terminatedAt","reservationReleasedAt","createdAt","defaultNow","updatedAt","table","on","where","toProvisionedRunner","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAEtF,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,6BAA6BN,OAAO,oCAAoC;IACnF;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMO,qBAAqBF,QAChC,uBACA;IACEG,IAAIX;IACJY,aAAaL,KAAK,gBAAgBM,OAAO;IACzCC,eAAeP,KAAK,kBAAkBM,OAAO;IAC7CE,qBAAqBX,KAAK,yBAAyBS,OAAO;IAC1DG,eAAeT,KAAK;IACpBU,aAAab,KAAK;IAClBc,QAAQd,KAAK,UAAUe,KAAK,GAAGN,OAAO;IACtCO,OAAOX,2BAA2B,SAASI,OAAO;IAClDQ,QAAQjB,KAAK;IACbkB,iBAAiBf,KAAK;IACtBgB,cAAcnB,KAAK;IACnBoB,YAAYnB,UAAU,eAAe;QAACoB,cAAc;IAAI,GAAGZ,OAAO;IAClEa,WAAWrB,UAAU,cAAc;QAACoB,cAAc;IAAI;IACtDE,YAAYtB,UAAU,eAAe;QAACoB,cAAc;IAAI;IACxDG,WAAWvB,UAAU,cAAc;QAACoB,cAAc;IAAI;IACtDI,UAAUxB,UAAU,aAAa;QAACoB,cAAc;IAAI;IACpDK,cAAczB,UAAU,iBAAiB;QAACoB,cAAc;IAAI;IAC5DM,uBAAuB1B,UAAU,2BAA2B;QAACoB,cAAc;IAAI;IAC/EO,WAAW3B,UAAU,cAAc;QAACoB,cAAc;IAAI,GAAGZ,OAAO,GAAGoB,UAAU;IAC7EC,WAAW7B,UAAU,cAAc;QAACoB,cAAc;IAAI,GAAGZ,OAAO,GAAGoB,UAAU;AAC/E,GACA,CAACE,QAAU;QACT7B,YAAY,mEAAmE8B,EAAE,CAC/ED,MAAMvB,WAAW,EACjBuB,MAAMrB,aAAa,EACnBqB,MAAMpB,mBAAmB;QAE3Bb,MAAM,2DAA2DkC,EAAE,CACjED,MAAMvB,WAAW,EACjBuB,MAAMf,KAAK,EACXe,MAAMD,SAAS;QAEjBhC,MAAM,gDAAgDkC,EAAE,CACtDD,MAAMf,KAAK,EACXe,MAAMD,SAAS,EACfC,MAAMX,UAAU,EAChBW,MAAMvB,WAAW;QAEnBV,MAAM,0DACHkC,EAAE,CAACD,MAAMvB,WAAW,EAAEuB,MAAMrB,aAAa,EAAEqB,MAAMf,KAAK,EAAEe,MAAMlB,WAAW,EACzEoB,KAAK,CAACpC,GAAG,CAAC,iEAAiE,CAAC;KAChF,EACD;AAKF,OAAO,SAASqC,oBAAoBC,GAAwB;IAC1D,OAAO;QACL5B,IAAI4B,IAAI5B,EAAE;QACVC,aAAa2B,IAAI3B,WAAW;QAC5BE,eAAeyB,IAAIzB,aAAa;QAChCC,qBAAqBwB,IAAIxB,mBAAmB;QAC5CC,eAAeuB,IAAIvB,aAAa;QAChCC,aAAasB,IAAItB,WAAW;QAC5BC,QAAQqB,IAAIrB,MAAM;QAClBE,OAAOmB,IAAInB,KAAK;QAChBC,QAAQkB,IAAIlB,MAAM;QAClBC,iBAAiBiB,IAAIjB,eAAe;QACpCC,cAAcgB,IAAIhB,YAAY;QAC9BC,YAAYe,IAAIf,UAAU;QAC1BE,WAAWa,IAAIb,SAAS;QACxBC,YAAYY,IAAIZ,UAAU;QAC1BC,WAAWW,IAAIX,SAAS;QACxBC,UAAUU,IAAIV,QAAQ;QACtBC,cAAcS,IAAIT,YAAY;QAC9BC,uBAAuBQ,IAAIR,qBAAqB;QAChDC,WAAWO,IAAIP,SAAS;QACxBE,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/schema/provisioner-tokens.d.ts

@@ -0,0 +1,216 @@
+import type { ProvisionerToken } from '#core/entities/provisioner-token.js';
+export declare const provisionerTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "provisioner_tokens";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "provisioner_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: "provisioner_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: "provisioner_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: "provisioner_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: "provisioner_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;
+        }, {}, {}>;
+        createdByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by_user_id";
+            tableName: "provisioner_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;
+        }, {}, {}>;
+        revokedByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "revoked_by_user_id";
+            tableName: "provisioner_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;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "provisioner_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: "provisioner_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;
+        }, {}, {}>;
+        lastSeenAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_seen_at";
+            tableName: "provisioner_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: "provisioner_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: "provisioner_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 ProvisionerTokenDb = typeof provisionerTokens.$inferSelect;
+export type ProvisionerTokenInsertDb = typeof provisionerTokens.$inferInsert;
+export declare function toProvisionerToken(row: ProvisionerTokenDb): ProvisionerToken;
+//# sourceMappingURL=provisioner-tokens.d.ts.map

package/dist/db/schema/provisioner-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisioner-tokens.d.ts","sourceRoot":"","sources":["../../../src/db/schema/provisioner-tokens.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,qCAAqC,CAAC;AAG1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB7B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACvE,MAAM,MAAM,wBAAwB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AAE7E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,GAAG,gBAAgB,CAe5E"}

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

@@ -0,0 +1,48 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const provisionerTokens = pgTable('provisioner_tokens', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    name: text('name'),
+    createdByUserId: uuid('created_by_user_id').notNull(),
+    revokedByUserId: uuid('revoked_by_user_id'),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }),
+    revokedAt: timestamp('revoked_at', {
+        withTimezone: true
+    }),
+    lastSeenAt: timestamp('last_seen_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).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())
+    ]);
+export function toProvisionerToken(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        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
+    };
+}
+
+//# sourceMappingURL=provisioner-tokens.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,145 @@
+export declare const runnersRateLimits: 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 RunnersRateLimitDb = typeof runnersRateLimits.$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,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB7B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC"}

package/dist/db/schema/rate-limits.js

@@ -0,0 +1,25 @@
+import { index, integer, text, timestamp, uniqueIndex } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const runnersRateLimits = pgTable('rate_limits', {
+    action: text('action').notNull(),
+    scope: text('scope').notNull(),
+    identifierHmac: text('identifier_hmac').notNull(),
+    windowStart: timestamp('window_start', {
+        withTimezone: true
+    }).notNull(),
+    count: integer('count').notNull().default(1),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('runners_rate_limits_window_unique').on(table.action, table.scope, table.identifierHmac, table.windowStart),
+        index('runners_rate_limits_expires_at_idx').on(table.expiresAt)
+    ]);
+
+//# sourceMappingURL=rate-limits.js.map

package/dist/db/schema/rate-limits.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/rate-limits.ts"],"sourcesContent":["import {index, integer, text, timestamp, uniqueIndex} from 'drizzle-orm/pg-core';\nimport {pgTable} from './common.js';\n\nexport const runnersRateLimits = pgTable(\n  'rate_limits',\n  {\n    action: text('action').notNull(),\n    scope: text('scope').notNull(),\n    identifierHmac: text('identifier_hmac').notNull(),\n    windowStart: timestamp('window_start', {withTimezone: true}).notNull(),\n    count: integer('count').notNull().default(1),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_rate_limits_window_unique').on(\n      table.action,\n      table.scope,\n      table.identifierHmac,\n      table.windowStart,\n    ),\n    index('runners_rate_limits_expires_at_idx').on(table.expiresAt),\n  ],\n);\n\nexport type RunnersRateLimitDb = typeof runnersRateLimits.$inferSelect;\n"],"names":["index","integer","text","timestamp","uniqueIndex","pgTable","runnersRateLimits","action","notNull","scope","identifierHmac","windowStart","withTimezone","count","default","expiresAt","createdAt","defaultNow","updatedAt","table","on"],"mappings":"AAAA,SAAQA,KAAK,EAAEC,OAAO,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,QAAO,sBAAsB;AACjF,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,oBAAoBD,QAC/B,eACA;IACEE,QAAQL,KAAK,UAAUM,OAAO;IAC9BC,OAAOP,KAAK,SAASM,OAAO;IAC5BE,gBAAgBR,KAAK,mBAAmBM,OAAO;IAC/CG,aAAaR,UAAU,gBAAgB;QAACS,cAAc;IAAI,GAAGJ,OAAO;IACpEK,OAAOZ,QAAQ,SAASO,OAAO,GAAGM,OAAO,CAAC;IAC1CC,WAAWZ,UAAU,cAAc;QAACS,cAAc;IAAI,GAAGJ,OAAO;IAChEQ,WAAWb,UAAU,cAAc;QAACS,cAAc;IAAI,GAAGJ,OAAO,GAAGS,UAAU;IAC7EC,WAAWf,UAAU,cAAc;QAACS,cAAc;IAAI,GAAGJ,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACE,QAAU;QACTf,YAAY,qCAAqCgB,EAAE,CACjDD,MAAMZ,MAAM,EACZY,MAAMV,KAAK,EACXU,MAAMT,cAAc,EACpBS,MAAMR,WAAW;QAEnBX,MAAM,sCAAsCoB,EAAE,CAACD,MAAMJ,SAAS;KAC/D,EACD"}