rename apiKey to ApiAccess

jjnp · jjnp · commit 1a8ed132f6a2 · 2024-06-02T13:53:18.000+02:00
diff --git a/services/src/auth/api-access-repository.integration.test.ts b/services/src/auth/api-access-repository.integration.test.ts
@@ -2,14 +2,14 @@ import { beforeEach, describe, expect, it } from 'vitest'
 import { db } from '../db/database'
 import { runMigration } from '../db/database-migration-util'
 import { createProject } from '../project/project.repository'
-import type { ProjectId } from '../../../src/routes/(api)/api/api.model'
 import {
-  createApiKey,
-  deleteApiKey,
-  getApiKeysForProject,
+  createApiAccess,
+  deleteApiAccess,
+  getApiAccessForProject,
   projectHasKey,
-  setApiKeyName
-} from './api-key.repository'
+  setApiAccessName
+} from './api-access.repository'
+import type { ProjectId } from '../project/project'
 
 beforeEach(async () => {
   db.reset()
@@ -22,94 +22,94 @@ describe('ApiKey Repository', () => {
     projectId = (await createProject({ name: 'demo project name' })).id as ProjectId
   })
 
-  describe('createApiKey', () => {
+  describe('createApiAccess', () => {
     it('should create an api key given an existing project', async () => {
-      const result = await createApiKey(projectId)
+      const result = await createApiAccess(projectId)
       expect(result).toBeTruthy()
       expect(false).toBeFalsy()
     })
   })
 
-  describe('getApiKeysForProject', () => {
+  describe('getApiAccessForProject', () => {
     it('should fetch all apiKeys for a given project', async () => {
-      const key1 = await createApiKey(projectId)
-      const key2 = await createApiKey(projectId)
+      const access1 = await createApiAccess(projectId)
+      const access2 = await createApiAccess(projectId)
 
-      const result = (await getApiKeysForProject(projectId)).map((it) => it.key)
-      expect(result).toHaveLength(2)
-      expect(result).includes(key1.key)
-      expect(result).includes(key2.key)
+      const keys = (await getApiAccessForProject(projectId)).map((it) => it.apikey)
+      expect(keys).toHaveLength(2)
+      expect(keys).includes(access1.apikey)
+      expect(keys).includes(access2.apikey)
     })
 
     it('should retrieve the name of the apiKey when it is created with one', async () => {
       const name = 'some key name'
-      const key = await createApiKey(projectId, name)
-      const result = await getApiKeysForProject(projectId)
+      const key = await createApiAccess(projectId, name)
+      const result = await getApiAccessForProject(projectId)
 
-      expect(result.find((it) => it.key === key.key)?.name).toBe(name)
+      expect(result.find((it) => it.apikey === key.apikey)?.name).toBe(name)
     })
 
     it('should no longer find deleted keys', async () => {
-      const key = await createApiKey(projectId)
+      const key = await createApiAccess(projectId)
 
-      const keysBeforeDelete = await getApiKeysForProject(projectId)
-      expect(keysBeforeDelete.map((it) => it.key)).toContain(key.key)
+      const keysBeforeDelete = await getApiAccessForProject(projectId)
+      expect(keysBeforeDelete.map((it) => it.apikey)).toContain(key.apikey)
 
-      await deleteApiKey(projectId, key.key)
-      const keysAfterDelete = await getApiKeysForProject(projectId)
-      expect(keysAfterDelete.map((it) => it.key).includes(key.key)).toBe(false)
+      await deleteApiAccess(projectId, key.apikey)
+      const keysAfterDelete = await getApiAccessForProject(projectId)
+      expect(keysAfterDelete.map((it) => it.apikey).includes(key.apikey)).toBe(false)
     })
 
     it('should return an empty list in case the project does not exist', async () => {
-      const keys = await getApiKeysForProject(projectId)
+      const keys = await getApiAccessForProject(projectId)
       expect(keys).toHaveLength(0)
     })
 
     it('should return an empty list if there are no keys', async () => {
-      const result = await getApiKeysForProject(projectId)
+      const result = await getApiAccessForProject(projectId)
       expect(result).toHaveLength(0)
     })
   })
 
-  describe('setApiKeyName', () => {
+  describe('setApiAccessName', () => {
     it('should be able to set a name when previously there was none', async () => {
-      const key = await createApiKey(projectId)
-      const initialRetrieval = await getApiKeysForProject(projectId).then((it) =>
-        it.find((apiKey) => apiKey.key === key.key)
+      const key = await createApiAccess(projectId)
+      const initialRetrieval = await getApiAccessForProject(projectId).then((it) =>
+        it.find((apiKey) => apiKey.apikey === key.apikey)
       )
 
       expect(initialRetrieval?.name).toBeFalsy()
       const updatedName = 'some new apiKeyName'
-      await setApiKeyName(key.id, updatedName)
+      await setApiAccessName(key.id, updatedName)
 
-      const secondRetrieval = await getApiKeysForProject(projectId).then((it) =>
-        it.find((apiKey) => apiKey.key === key.key)
+      const secondRetrieval = await getApiAccessForProject(projectId).then((it) =>
+        it.find((apiKey) => apiKey.apikey === key.apikey)
       )
       expect(secondRetrieval?.name).toBe(updatedName)
     })
 
     it('should be able to set the name', async () => {
       const initialName = 'my personal api key'
-      const key = await createApiKey(projectId, initialName)
-      const initialRetrieval = await getApiKeysForProject(projectId).then((it) =>
-        it.find((apiKey) => apiKey.key === key.key)
+      const key = await createApiAccess(projectId, initialName)
+      const initialRetrieval = await getApiAccessForProject(projectId).then((it) =>
+        it.find((apiKey) => apiKey.apikey === key.apikey)
       )
 
       expect(initialRetrieval?.name).toBe(initialName)
       const updatedName = 'some new apiKeyName'
-      await setApiKeyName(key.id, updatedName)
+      await setApiAccessName(key.id, updatedName)
 
-      const secondRetrieval = await getApiKeysForProject(projectId).then((it) =>
-        it.find((apiKey) => apiKey.key === key.key)
+      const secondRetrieval = await getApiAccessForProject(projectId).then((it) =>
+        it.find((apiKey) => apiKey.apikey === key.apikey)
       )
       expect(secondRetrieval?.name).toBe(updatedName)
     })
   })
 
   describe('projectHasKey', () => {
     it('should return true if there is a key for the project', async () => {
-      const key = await createApiKey(projectId)
-      const result = await projectHasKey(projectId, key.key)
+      const key = await createApiAccess(projectId)
+      const result = await projectHasKey(projectId, key.apikey)
       expect(result).toBe(true)
     })
 
@@ -125,9 +125,9 @@ describe('ApiKey Repository', () => {
 
     it('should return false if key and project exist, but do not match', async () => {
       const otherProjectId = (await createProject({ name: 'another Project' })).id as ProjectId
-      const key = await createApiKey(projectId)
+      const key = await createApiAccess(projectId)
 
-      const result = await projectHasKey(otherProjectId, key.key)
+      const result = await projectHasKey(otherProjectId, key.apikey)
       expect(result).toBe(false)
     })
   })
diff --git a/services/src/auth/api-access-service.test.ts b/services/src/auth/api-access-service.test.ts
diff --git a/services/src/auth/api-access.repository.ts b/services/src/auth/api-access.repository.ts
@@ -1,52 +1,52 @@
 import { db } from '../db/database'
-import type { ApiKeyCreationParams, SelectableApiKey } from './api-key'
+import type { ApiKeyCreationParams, SelectableApiKey } from './api-access'
 import { v4 as uuid } from 'uuid'
 
-export function createApiKey(
+export function createApiAccess(
 	projectId: number,
 	name: string | null = null
 ): Promise<SelectableApiKey> {
 	const insertKey: ApiKeyCreationParams = {
-		key: uuid(),
+		apikey: uuid(),
 		name,
 		project_id: projectId
 	}
 	return db
-		.insertInto('apikeys')
+		.insertInto('apiaccess')
 		.values(insertKey)
 		.returningAll()
 		.executeTakeFirstOrThrow(() => new Error('Error creating Api Access Key'))
 }
 
-export function getApiKeysForProject(projectId: number): Promise<SelectableApiKey[]> {
-	return db.selectFrom('apikeys').selectAll().where('project_id', '==', projectId).execute()
+export function getApiAccessForProject(projectId: number): Promise<SelectableApiKey[]> {
+	return db.selectFrom('apiaccess').selectAll().where('project_id', '==', projectId).execute()
 }
 
-export async function setApiKeyName(keyId: number, name: string): Promise<void> {
+export async function setApiAccessName(keyId: number, name: string): Promise<void> {
 	await db
-		.updateTable('apikeys')
+		.updateTable('apiaccess')
 		.set({
 			name
 		})
 		.where('id', '==', keyId)
 		.execute()
 }
 
-export async function projectHasKey(projectId: number, key: string): Promise<boolean> {
+export async function projectHasKey(projectId: number, apikey: string): Promise<boolean> {
 	const result = await db
-		.selectFrom('apikeys')
+		.selectFrom('apiaccess')
 		.selectAll()
 		.where('project_id', '==', projectId)
-		.where('key', '==', key)
+		.where('apikey', '==', apikey)
 		.execute()
 
 	return !!result.length
 }
 
-export async function deleteApiKey(projectId: number, key: string): Promise<void> {
+export async function deleteApiAccess(projectId: number, apikey: string): Promise<void> {
 	await db
-		.deleteFrom('apikeys')
+		.deleteFrom('apiaccess')
 		.where('project_id', '==', projectId)
-		.where('key', '==', key)
+		.where('apikey', '==', apikey)
 		.execute()
 }
diff --git a/services/src/auth/api-access.service.ts b/services/src/auth/api-access.service.ts
@@ -0,0 +1,24 @@
+import {
+  createApiAccess,
+  getApiAccessForProject,
+  projectHasKey,
+  setApiAccessName
+} from './api-access.repository'
+
+export const checkApiKeyAccess = async (apiKey: string, projectId: number): Promise<boolean> => {
+  return await projectHasKey(projectId, apiKey)
+}
+
+export const addApiKey = async (projectId: number): Promise<string> => {
+  const key = await createApiAccess(projectId)
+  return key.apikey
+}
+
+export const changeApiKeyName = async (apiAccessId: number, name: string) => {
+  await setApiAccessName(apiAccessId, name)
+}
+
+export const listApiKeys = async (projectId: number): Promise<string[]> => {
+  const result = await getApiAccessForProject(projectId)
+  return result.map((it) => it.apikey)
+}
diff --git a/services/src/auth/api-access.ts b/services/src/auth/api-access.ts
@@ -0,0 +1,22 @@
+import type { Insertable, Selectable } from 'kysely'
+import type { Apiaccess } from 'kysely-codegen'
+import { z } from 'zod'
+
+export type ApiKeyCreationParams = Insertable<Omit<Apiaccess, 'id' | 'created_at'>>
+export type SelectableApiKey = Selectable<Apiaccess>
+
+const apiKeyIdSchema = z.number().brand('api-access')
+export type ApiKeyId = z.infer<typeof apiKeyIdSchema>
+
+const apiKeyKeySchema = z.string().uuid().brand('api-key')
+export type ApiKey = z.infer<typeof apiKeyKeySchema>
+
+const apiAccessSchema = z.object({
+  id: apiKeyIdSchema,
+  apikey: apiKeyKeySchema,
+  name: z.string(),
+  project_id: z.number(),
+  created_at: z.date(),
+  updated_at: z.date()
+})
+export type ApiAccess = z.infer<typeof apiAccessSchema>
diff --git a/services/src/auth/api-key.service.ts b/services/src/auth/api-key.service.ts
diff --git a/services/src/auth/api-key.ts b/services/src/auth/api-key.ts
diff --git a/services/src/kysely/migrations/2024-05-16T19:00:00Z_apikey.ts b/services/src/kysely/migrations/2024-05-16T19:00:00Z_apikey.ts
@@ -2,8 +2,8 @@ import { Kysely } from 'kysely'
 import { createTableMigration } from '../migration.util'
 
 export async function up(db: Kysely<unknown>): Promise<void> {
-	await createTableMigration(db, 'apikeys')
-		.addColumn('key', 'text', (col) => col.unique().notNull())
+	await createTableMigration(db, 'apiaccess')
+		.addColumn('apikey', 'text', (col) => col.unique().notNull())
 		.addColumn('name', 'text')
 		.addColumn('project_id', 'integer', (col) =>
 			col.references('projects.id').onDelete('cascade').notNull()
@@ -12,5 +12,5 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 }
 
 export async function down(db: Kysely<unknown>): Promise<void> {
-	await db.schema.dropTable('apikeys').execute()
+	await db.schema.dropTable('apiaccess').execute()
 }
diff --git a/src/routes/(api)/api/[project]/[lang]/translations/+server.ts b/src/routes/(api)/api/[project]/[lang]/translations/+server.ts
@@ -4,15 +4,15 @@ import { translationPOSTRequestSchema, type ProjectId } from '../../../api.model
 import type { RequestHandler } from './$types'
 
 export const POST: RequestHandler = async ({ params, request }) => {
-	authorize(request, params.project as ProjectId)
+	authorize(request, +params.project as ProjectId)
 	const newTranslations = validateRequestBody(request, translationPOSTRequestSchema)
 	return new Response(
 		`getting POST for translations on project "${params.project}" and lang "${params.lang}" with body "${JSON.stringify(newTranslations)}"`
 	)
 }
 
 export const GET: RequestHandler = ({ params, request }) => {
-	authorize(request, params.project as ProjectId)
+	authorize(request, +params.project as ProjectId)
 	return new Response(
 		`getting GET for translations on project "${params.project}" and lang "${params.lang}"`
 	)
diff --git a/src/routes/(api)/api/[project]/config/+server.ts b/src/routes/(api)/api/[project]/config/+server.ts
@@ -4,7 +4,7 @@ import { projectConfigPOSTRequestSchema, type ProjectId } from '../../api.model'
 import type { RequestHandler } from './$types'
 
 export const POST: RequestHandler = async ({ params, request }) => {
-	authorize(request, params.project as ProjectId)
+	authorize(request, +params.project as ProjectId)
 	const config = await validateRequestBody(request, projectConfigPOSTRequestSchema)
 
 	return new Response(
diff --git a/src/routes/(api)/api/api-utils.ts b/src/routes/(api)/api/api-utils.ts
@@ -1,4 +1,4 @@
-import { checkApiKeyAccess } from 'services/auth/api-key.service'
+import { checkApiKeyAccess } from 'services/auth/api-access.service'
 import type { ProjectId } from './api.model'
 import { error } from '@sveltejs/kit'
 

Original file line number	Diff line number	Diff line change
`@@ -4,15 +4,15 @@ import { translationPOSTRequestSchema, type ProjectId } from '../../../api.model`
`4`	`4`	`import type { RequestHandler } from './$types'`
`5`	`5`
`6`	`6`	`export const POST: RequestHandler = async ({ params, request }) => {`
`7`		`- authorize(request, params.project as ProjectId)`
	`7`	`+ authorize(request, +params.project as ProjectId)`
`8`	`8`	`const newTranslations = validateRequestBody(request, translationPOSTRequestSchema)`
`9`	`9`	`return new Response(`
`10`	`10`	`getting POST for translations on project "${params.project}" and lang "${params.lang}" with body "${JSON.stringify(newTranslations)}"`
`11`	`11`	`)`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`export const GET: RequestHandler = ({ params, request }) => {`
`15`		`- authorize(request, params.project as ProjectId)`
	`15`	`+ authorize(request, +params.project as ProjectId)`
`16`	`16`	`return new Response(`
`17`	`17`	`getting GET for translations on project "${params.project}" and lang "${params.lang}"`
`18`	`18`	`)`