@pikku/kysely 0.12.6 → 0.12.8

package/src/kysely-channel-store.ts

@@ -57,9 +57,9 @@ export class KyselyChannelStore extends ChannelStore {
     await this.db
       .insertInto('channels')
       .values({
-        channel_id: channelId,
-        channel_name: channelName,
-        opening_data: JSON.stringify(openingData || {}),
+        channelId: channelId,
+        channelName: channelName,
+        openingData: JSON.stringify(openingData || {}),
       })
       .execute()
   }
@@ -71,7 +71,7 @@ export class KyselyChannelStore extends ChannelStore {
 
     await this.db
       .deleteFrom('channels')
-      .where('channel_id', 'in', channelIds)
+      .where('channelId', 'in', channelIds)
       .execute()
   }
 
@@ -81,8 +81,8 @@ export class KyselyChannelStore extends ChannelStore {
   ): Promise<void> {
     await this.db
       .updateTable('channels')
-      .set({ user_session: session ? JSON.stringify(session) : null })
-      .where('channel_id', '=', channelId)
+      .set({ userSession: session ? JSON.stringify(session) : null })
+      .where('channelId', '=', channelId)
       .execute()
   }
 
@@ -91,8 +91,8 @@ export class KyselyChannelStore extends ChannelStore {
   ): Promise<Channel & { session: CoreUserSession }> {
     const row = await this.db
       .selectFrom('channels')
-      .select(['channel_id', 'channel_name', 'opening_data', 'user_session'])
-      .where('channel_id', '=', channelId)
+      .select(['channelId', 'channelName', 'openingData', 'userSession'])
+      .where('channelId', '=', channelId)
       .executeTakeFirst()
 
     if (!row) {
@@ -100,10 +100,10 @@ export class KyselyChannelStore extends ChannelStore {
     }
 
     return {
-      channelId: row.channel_id,
-      channelName: row.channel_name,
-      openingData: parseJson(row.opening_data) ?? {},
-      session: (parseJson(row.user_session) ?? {}) as CoreUserSession,
+      channelId: row.channelId,
+      channelName: row.channelName,
+      openingData: parseJson(row.openingData) ?? {},
+      session: (parseJson(row.userSession) ?? {}) as CoreUserSession,
     }
   }
 

package/src/kysely-credential-service.ts

@@ -84,13 +84,13 @@ export class KyselyCredentialService implements CredentialService {
     if (action === 'read' && !this.auditReads) return
 
     await this.db
-      .insertInto('credentials_audit')
+      .insertInto('credentialsAudit')
       .values({
         id: crypto.randomUUID(),
-        credential_name: name,
-        user_id: userId ?? null,
+        credentialName: name,
+        userId: userId ?? null,
         action,
-        performed_at: new Date().toISOString() as any,
+        performedAt: new Date().toISOString() as unknown as Date,
       })
       .execute()
   }
@@ -103,25 +103,25 @@ export class KyselyCredentialService implements CredentialService {
 
   private whereUserId(qb: any, userId?: string) {
     return userId
-      ? qb.where('user_id', '=', userId)
-      : qb.where('user_id', 'is', null)
+      ? qb.where('userId', '=', userId)
+      : qb.where('userId', 'is', null)
   }
 
   async get<T = unknown>(name: string, userId?: string): Promise<T | null> {
     let qb = this.db
       .selectFrom('credentials')
-      .select(['ciphertext', 'wrapped_dek', 'key_version'])
+      .select(['ciphertext', 'wrappedDek', 'keyVersion'])
       .where('name', '=', name)
     qb = this.whereUserId(qb, userId)
 
     const row = await qb.executeTakeFirst()
     if (!row) return null
 
-    const kek = this.getKEK(row.key_version)
+    const kek = this.getKEK(row.keyVersion)
     const plaintext = await envelopeDecrypt<string>(
       kek,
       row.ciphertext,
-      row.wrapped_dek
+      row.wrappedDek
     )
     await this.logAudit(name, userId, 'read')
 
@@ -146,9 +146,9 @@ export class KyselyCredentialService implements CredentialService {
         .updateTable('credentials')
         .set({
           ciphertext,
-          wrapped_dek: wrappedDEK,
-          key_version: this.keyVersion,
-          updated_at: now as any,
+          wrappedDek: wrappedDEK,
+          keyVersion: this.keyVersion,
+          updatedAt: now as unknown as Date,
         })
         .where('name', '=', name)
       qb = this.whereUserId(qb, userId)
@@ -158,12 +158,12 @@ export class KyselyCredentialService implements CredentialService {
         .insertInto('credentials')
         .values({
           name,
-          user_id: userId ?? null,
+          userId: userId ?? null,
           ciphertext,
-          wrapped_dek: wrappedDEK,
-          key_version: this.keyVersion,
-          created_at: now as any,
-          updated_at: now as any,
+          wrappedDek: wrappedDEK,
+          keyVersion: this.keyVersion,
+          createdAt: now as unknown as Date,
+          updatedAt: now as unknown as Date,
         })
         .execute()
     }
@@ -193,17 +193,17 @@ export class KyselyCredentialService implements CredentialService {
   async getAll(userId: string): Promise<Record<string, unknown>> {
     const rows = await this.db
       .selectFrom('credentials')
-      .select(['name', 'ciphertext', 'wrapped_dek', 'key_version'])
-      .where('user_id', '=', userId)
+      .select(['name', 'ciphertext', 'wrappedDek', 'keyVersion'])
+      .where('userId', '=', userId)
       .execute()
 
     const result: Record<string, unknown> = {}
     for (const row of rows) {
-      const kek = this.getKEK(row.key_version)
+      const kek = this.getKEK(row.keyVersion)
       const plaintext = await envelopeDecrypt<string>(
         kek,
         row.ciphertext,
-        row.wrapped_dek
+        row.wrappedDek
       )
       try {
         result[row.name] = JSON.parse(plaintext)
@@ -216,6 +216,28 @@ export class KyselyCredentialService implements CredentialService {
     return result
   }
 
+  async getUsersWithCredential(name: string): Promise<string[]> {
+    const rows = await this.db
+      .selectFrom('credentials')
+      .select('userId')
+      .where('name', '=', name)
+      .where('userId', 'is not', null)
+      .execute()
+
+    return rows.map((row) => row.userId!).filter(Boolean)
+  }
+
+  async getAllUsers(): Promise<string[]> {
+    const rows = await this.db
+      .selectFrom('credentials')
+      .select('userId')
+      .distinct()
+      .where('userId', 'is not', null)
+      .execute()
+
+    return rows.map((row) => row.userId!).filter(Boolean)
+  }
+
   async rotateKEK(): Promise<number> {
     if (!this.previousKey) {
       throw new Error('No previousKey configured — nothing to rotate from')
@@ -223,28 +245,28 @@ export class KyselyCredentialService implements CredentialService {
 
     const rows = await this.db
       .selectFrom('credentials')
-      .select(['name', 'user_id', 'wrapped_dek'])
-      .where('key_version', '<', this.keyVersion)
+      .select(['name', 'userId', 'wrappedDek'])
+      .where('keyVersion', '<', this.keyVersion)
       .execute()
 
     for (const row of rows) {
       const newWrappedDEK = await envelopeRewrap(
         this.previousKey,
         this.key,
-        row.wrapped_dek
+        row.wrappedDek
       )
       let qb = this.db
         .updateTable('credentials')
         .set({
-          wrapped_dek: newWrappedDEK,
-          key_version: this.keyVersion,
-          updated_at: new Date().toISOString() as any,
+          wrappedDek: newWrappedDEK,
+          keyVersion: this.keyVersion,
+          updatedAt: new Date().toISOString() as unknown as Date,
         })
         .where('name', '=', row.name)
-      qb = this.whereUserId(qb, row.user_id ?? undefined)
+      qb = this.whereUserId(qb, row.userId ?? undefined)
       await qb.execute()
 
-      await this.logAudit(row.name, row.user_id ?? undefined, 'rotate')
+      await this.logAudit(row.name, row.userId ?? undefined, 'rotate')
     }
 
     return rows.length

package/src/kysely-deployment-service.ts

@@ -83,32 +83,32 @@ export class KyselyDeploymentService implements DeploymentService {
 
     await this.db.transaction().execute(async (trx) => {
       await trx
-        .insertInto('pikku_deployments')
+        .insertInto('pikkuDeployments')
         .values({
-          deployment_id: config.deploymentId,
+          deploymentId: config.deploymentId,
           endpoint: config.endpoint,
-          last_heartbeat: new Date(),
+          lastHeartbeat: new Date(),
         })
         .onConflict((oc) =>
-          oc.column('deployment_id').doUpdateSet({
+          oc.column('deploymentId').doUpdateSet({
             endpoint: config.endpoint,
-            last_heartbeat: new Date(),
+            lastHeartbeat: new Date(),
           })
         )
         .execute()
 
       await trx
-        .deleteFrom('pikku_deployment_functions')
-        .where('deployment_id', '=', config.deploymentId)
+        .deleteFrom('pikkuDeploymentFunctions')
+        .where('deploymentId', '=', config.deploymentId)
         .execute()
 
       if (functions.length > 0) {
         await trx
-          .insertInto('pikku_deployment_functions')
+          .insertInto('pikkuDeploymentFunctions')
           .values(
             functions.map((fn) => ({
-              deployment_id: config.deploymentId,
-              function_name: fn,
+              deploymentId: config.deploymentId,
+              functionName: fn,
             }))
           )
           .execute()
@@ -129,8 +129,8 @@ export class KyselyDeploymentService implements DeploymentService {
 
     if (this.deploymentConfig) {
       await this.db
-        .deleteFrom('pikku_deployments')
-        .where('deployment_id', '=', this.deploymentConfig.deploymentId)
+        .deleteFrom('pikkuDeployments')
+        .where('deploymentId', '=', this.deploymentConfig.deploymentId)
         .execute()
     }
   }
@@ -140,20 +140,20 @@ export class KyselyDeploymentService implements DeploymentService {
     const cutoff = new Date(Date.now() - ttlMs)
 
     const result = await this.db
-      .selectFrom('pikku_deployments as d')
+      .selectFrom('pikkuDeployments as d')
       .innerJoin(
-        'pikku_deployment_functions as f',
-        'f.deployment_id',
-        'd.deployment_id'
+        'pikkuDeploymentFunctions as f',
+        'f.deploymentId',
+        'd.deploymentId'
       )
-      .select(['d.deployment_id', 'd.endpoint'])
-      .where('f.function_name', '=', name)
-      .where('d.last_heartbeat', '>', cutoff)
-      .orderBy('d.last_heartbeat', 'desc')
+      .select(['d.deploymentId', 'd.endpoint'])
+      .where('f.functionName', '=', name)
+      .where('d.lastHeartbeat', '>', cutoff)
+      .orderBy('d.lastHeartbeat', 'desc')
       .execute()
 
     return result.map((row) => ({
-      deploymentId: row.deployment_id,
+      deploymentId: row.deploymentId,
       endpoint: row.endpoint,
     }))
   }
@@ -176,9 +176,9 @@ export class KyselyDeploymentService implements DeploymentService {
 
     try {
       await this.db
-        .updateTable('pikku_deployments')
-        .set({ last_heartbeat: new Date() })
-        .where('deployment_id', '=', this.deploymentConfig.deploymentId)
+        .updateTable('pikkuDeployments')
+        .set({ lastHeartbeat: new Date() })
+        .where('deploymentId', '=', this.deploymentConfig.deploymentId)
         .execute()
     } catch {
       // Heartbeat failed, will retry on next interval

package/src/kysely-eventhub-store.ts

@@ -18,20 +18,20 @@ export class KyselyEventHubStore extends EventHubStore {
 
   public async getChannelIdsForTopic(topic: string): Promise<string[]> {
     const result = await this.db
-      .selectFrom('channel_subscriptions')
-      .select('channel_id')
+      .selectFrom('channelSubscriptions')
+      .select('channelId')
       .where('topic', '=', topic)
       .execute()
 
-    return result.map((row) => row.channel_id)
+    return result.map((row) => row.channelId)
   }
 
   public async subscribe(topic: string, channelId: string): Promise<boolean> {
     try {
       await this.db
-        .insertInto('channel_subscriptions')
-        .values({ channel_id: channelId, topic: topic as string })
-        .onConflict((oc) => oc.columns(['channel_id', 'topic']).doNothing())
+        .insertInto('channelSubscriptions')
+        .values({ channelId: channelId, topic: topic as string })
+        .onConflict((oc) => oc.columns(['channelId', 'topic']).doNothing())
         .execute()
       return true
     } catch {
@@ -41,8 +41,8 @@ export class KyselyEventHubStore extends EventHubStore {
 
   public async unsubscribe(topic: string, channelId: string): Promise<boolean> {
     const result = await this.db
-      .deleteFrom('channel_subscriptions')
-      .where('channel_id', '=', channelId)
+      .deleteFrom('channelSubscriptions')
+      .where('channelId', '=', channelId)
       .where('topic', '=', topic as string)
       .executeTakeFirst()
 

package/src/kysely-secret-service.ts

@@ -77,12 +77,12 @@ export class KyselySecretService implements SecretService {
     if (action === 'read' && !this.auditReads) return
 
     await this.db
-      .insertInto('secrets_audit')
+      .insertInto('secretsAudit')
       .values({
         id: crypto.randomUUID(),
-        secret_key: secretKey,
+        secretKey: secretKey,
         action,
-        performed_at: new Date().toISOString() as any,
+        performedAt: new Date().toISOString() as unknown as Date,
       })
       .execute()
   }
@@ -96,17 +96,17 @@ export class KyselySecretService implements SecretService {
   async getSecret(key: string): Promise<string> {
     const row = await this.db
       .selectFrom('secrets')
-      .select(['ciphertext', 'wrapped_dek', 'key_version'])
+      .select(['ciphertext', 'wrappedDek', 'keyVersion'])
       .where('key', '=', key)
       .executeTakeFirst()
 
     if (!row) throw new Error('Requested secret not found')
 
-    const kek = this.getKEK(row.key_version)
+    const kek = this.getKEK(row.keyVersion)
     const result = await envelopeDecrypt<string>(
       kek,
       row.ciphertext,
-      row.wrapped_dek
+      row.wrappedDek
     )
     await this.logAudit(key, 'read')
     return result
@@ -139,17 +139,17 @@ export class KyselySecretService implements SecretService {
       .values({
         key,
         ciphertext,
-        wrapped_dek: wrappedDEK,
-        key_version: this.keyVersion,
-        created_at: now as any,
-        updated_at: now as any,
+        wrappedDek: wrappedDEK,
+        keyVersion: this.keyVersion,
+        createdAt: now as unknown as Date,
+        updatedAt: now as unknown as Date,
       })
       .onConflict((oc) =>
         oc.column('key').doUpdateSet({
           ciphertext,
-          wrapped_dek: wrappedDEK,
-          key_version: this.keyVersion,
-          updated_at: now as any,
+          wrappedDek: wrappedDEK,
+          keyVersion: this.keyVersion,
+          updatedAt: now as unknown as Date,
         })
       )
       .execute()
@@ -169,22 +169,22 @@ export class KyselySecretService implements SecretService {
 
     const rows = await this.db
       .selectFrom('secrets')
-      .select(['key', 'wrapped_dek'])
-      .where('key_version', '<', this.keyVersion)
+      .select(['key', 'wrappedDek'])
+      .where('keyVersion', '<', this.keyVersion)
       .execute()
 
     for (const row of rows) {
       const newWrappedDEK = await envelopeRewrap(
         this.previousKey,
         this.key,
-        row.wrapped_dek
+        row.wrappedDek
       )
       await this.db
         .updateTable('secrets')
         .set({
-          wrapped_dek: newWrappedDEK,
-          key_version: this.keyVersion,
-          updated_at: new Date().toISOString() as any,
+          wrappedDek: newWrappedDEK,
+          keyVersion: this.keyVersion,
+          updatedAt: new Date().toISOString() as unknown as Date,
         })
         .where('key', '=', row.key)
         .execute()

package/src/kysely-services.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, before, after } from 'node:test'
 import assert from 'node:assert/strict'
-import { Kysely, SqliteDialect } from 'kysely'
+import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
 import { SerializePlugin } from 'kysely-plugin-serialize'
 import Database from 'better-sqlite3'
 import { PostgresJSDialect } from 'kysely-postgres-js'
@@ -23,7 +23,7 @@ function createSqliteDb(): Kysely<KyselyPikkuDB> {
     dialect: new SqliteDialect({
       database: new Database(':memory:'),
     }),
-    plugins: [new SerializePlugin()],
+    plugins: [new CamelCasePlugin(), new SerializePlugin()],
   })
 }
 
@@ -33,6 +33,7 @@ function createPostgresDb(): Kysely<KyselyPikkuDB> | null {
 
   return new Kysely<KyselyPikkuDB>({
     dialect: new PostgresJSDialect({ postgres: postgres(url) }),
+    plugins: [new CamelCasePlugin()],
   })
 }
 
@@ -126,10 +127,10 @@ function registerTests(
       await service.deleteSecret('audit-test')
 
       const logs = await getDb()
-        .selectFrom('secrets_audit')
-        .select(['secret_key', 'action'])
-        .where('secret_key', '=', 'audit-test')
-        .orderBy('performed_at', 'asc')
+        .selectFrom('secretsAudit')
+        .select(['secretKey', 'action'])
+        .where('secretKey', '=', 'audit-test')
+        .orderBy('performedAt', 'asc')
         .execute()
 
       assert.equal(logs.length, 3)
@@ -149,9 +150,9 @@ function registerTests(
       await service.getSecret('no-read-audit')
 
       const logs = await getDb()
-        .selectFrom('secrets_audit')
+        .selectFrom('secretsAudit')
         .select(['action'])
-        .where('secret_key', '=', 'no-read-audit')
+        .where('secretKey', '=', 'no-read-audit')
         .execute()
 
       assert.equal(logs.length, 1)
@@ -174,15 +175,15 @@ function registerTests(
       await service.delete('audit-cred', 'user-1')
 
       const logs = await getDb()
-        .selectFrom('credentials_audit')
-        .select(['credential_name', 'user_id', 'action'])
-        .where('credential_name', '=', 'audit-cred')
-        .orderBy('performed_at', 'asc')
+        .selectFrom('credentialsAudit')
+        .select(['credentialName', 'userId', 'action'])
+        .where('credentialName', '=', 'audit-cred')
+        .orderBy('performedAt', 'asc')
         .execute()
 
       assert.equal(logs.length, 3)
       assert.equal(logs[0]!.action, 'write')
-      assert.equal(logs[0]!.user_id, 'user-1')
+      assert.equal(logs[0]!.userId, 'user-1')
       assert.equal(logs[1]!.action, 'read')
       assert.equal(logs[2]!.action, 'delete')
     })
@@ -198,14 +199,14 @@ function registerTests(
       await service.get('global-cred')
 
       const logs = await getDb()
-        .selectFrom('credentials_audit')
-        .select(['credential_name', 'user_id', 'action'])
-        .where('credential_name', '=', 'global-cred')
+        .selectFrom('credentialsAudit')
+        .select(['credentialName', 'userId', 'action'])
+        .where('credentialName', '=', 'global-cred')
         .execute()
 
       assert.equal(logs.length, 2)
-      assert.equal(logs[0]!.user_id, null)
-      assert.equal(logs[1]!.user_id, null)
+      assert.equal(logs[0]!.userId, null)
+      assert.equal(logs[1]!.userId, null)
     })
   })
 }