refactor: revert zod to Elysia Types for type safety, type soundness by DaxServer · Pull Request #163 · DaxServer/dataforge

DaxServer · 2025-09-27T16:08:50Z

No description provided.

coderabbitai · 2025-09-27T16:08:58Z

Caution

Review failed

The pull request is closed.

📝 Walkthrough

Summary by CodeRabbit

New Features
- Added Wikibase endpoint to fetch CSRF tokens.
- Enhanced API responses and validation across project and Wikibase routes.
Refactor
- Migrated backend validation from Zod to Elysia schemas, standardizing error formats.
- Create-schema request no longer includes projectId in the payload.
Chores
- Removed Zod dependency; upgraded Elysia; locked @primeuix/themes to 1.2.5.
Documentation
- Updated guidelines to reflect Elysia-based validation and type inference.
Tests
- Updated API tests to align with new validation, error shapes, and payload changes.

Walkthrough

Migrates backend validation from Zod to Elysia across APIs/types/tests, inlines route schemas, removes zod/OpenAPI mapping, adds a Wikibase CSRF endpoint, introduces closeDb(), updates frontend create-schema payload, pins a frontend theme, and updates docs/prompts.

Changes

Cohort / File(s)	Summary
Dependency updates `package.json`, `backend/package.json`, `frontend/package.json`	Remove `zod` from workspace/backend, bump `elysia` to 1.4.8, pin `@primeuix/themes` to `1.2.5`.
Backend: global schema migration (Zod → Elysia) `backend/src/types/error-schemas.ts`, `backend/src/types/wikibase-schema.ts`, `backend/src/api/project/schemas.ts`, `backend/src/api/_meta_projects.ts`	Replace Zod schemas with Elysia `t.*` equivalents; update exported type aliases to use `.static`; introduce UUID regex pattern and adjust various public types.
Backend: Project routes & import `backend/src/api/project/index.ts`, `backend/src/api/project/import.ts`	Move route schemas inline using Elysia `t`; add/expand response typings; remove exported `ProjectImportSchema` and `ProjectImportFileAltSchema`.
Backend: Wikibase types, routes & schemas `backend/src/api/project/project.wikibase.ts`, `backend/src/api/wikibase/schemas.ts`, `backend/src/api/wikibase/index.ts`	Convert Wikibase/Zod schemas to Elysia `t.*`; expose new public types (e.g., `WikibaseCreateSchema`), expand route typings/metadata, and add POST `/:instanceId/csrf-token`.
Backend: OpenAPI and boot `backend/src/index.ts`	Remove Zod import and zod→JSON schema mapping for OpenAPI generation.
Backend: Database lifecycle `backend/src/plugins/database.ts`	Add exported `closeDb()` and call it from `initializeDb()` for cleanup.
Frontend: schema API & errors `frontend/src/features/wikibase-schema/composables/useSchemaApi.ts`, `frontend/src/shared/types/client-errors.ts`	`createSchema` POST payload no longer includes `projectId`; rename `createFrontendError` parameter to `_message`.
Docs/Guides & prompts `guidelines/reference/ELYSIA_EDEN.md`, `prompts/Backend.md`, `prompts/Frontend.md`	Update guidance from Zod to Elysia-based validation and type inference.
Tests adjusted `backend/tests/api/project/project.create.test.ts`, `backend/tests/api/project/project.delete.test.ts`, `backend/tests/api/project/project.get.test.ts`, `backend/tests/api/project/project.wikibase.test.ts`, `frontend/src/features/wikibase-schema/composables/__tests__/useSchemaApi.test.ts`	Align assertions to new Elysia validation/error shape (schema-driven errors), import `UUID_REGEX`, update Wikibase test helpers/types and API composition; remove one deleted Wikibase entities test file.

Sequence Diagram(s)

sequenceDiagram
  autonumber
  actor Frontend
  participant Backend as "Backend Wikibase API"
  participant Wikibase as "Wikibase Service"

  rect rgb(242,248,255)
  note over Frontend,Backend: New CSRF token flow
  Frontend->>Backend: POST /wikibase/:instanceId/csrf-token { oauth? }
  Backend->>Wikibase: request tokens (action=query&meta=tokens&type=csrf)
  Wikibase-->>Backend: { query: { tokens: { csrftoken } } }
  Backend-->>Frontend: 200 { data: csrftoken } or 4xx/5xx ApiErrors
  end

sequenceDiagram
  autonumber
  actor Client
  participant API as "Backend API (projects/wikibase)"
  note over Client,API: Inline Elysia validation used in routes
  Client->>API: POST /projects { body }
  API->>API: Validate body using Elysia t.Object
  API-->>Client: 201 { data } or 4xx/422 ApiErrors (schema-shaped)

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

refactor: revert zod to Elysia Types for type safety, type soundness #163 — Broad Zod→Elysia migration across backend schemas and routes; highly overlapping refactor.
feat(wikibase-schema-types): enforce types for wikibase schema APIs #119 — Reworks Wikibase schema/types in project.wikibase.ts; closely related to exposed types here.
feat: expand MediaWiki Action API integration #156 — Modifies Wikibase schema/type layer (ItemId/PropertyId/Value types); intersects with this PR's type changes.

Pre-merge checks and finishing touches

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Description Check	⚠️ Warning	The pull request description is empty and does not provide any details about the changes made, leaving reviewers without context or an overview of the migration from Zod to Elysia schemas.	Please add a brief description summarizing the main objectives of this refactor, such as migrating schema definitions from Zod to Elysia types and highlighting any key impacts on the API surface and tests.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Title Check	✅ Passed	The title explicitly refers to the refactoring change from Zod to Elysia types, which is the primary change affecting schema definitions and runtime validations throughout the codebase, making it a clear and focused summary of the main change.
Docstring Coverage	✅ Passed	No functions found in the changes. Docstring coverage check skipped.

📜 Recent review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 0134491 and 5ea3cfb.

📒 Files selected for processing (3)

backend/src/api/wikibase/schemas.ts (1 hunks)
backend/tests/api/wikibase/entities.test.ts (0 hunks)
frontend/src/features/wikibase-schema/composables/__tests__/useSchemaApi.test.ts (0 hunks)

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

coderabbitai

Actionable comments posted: 13

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (10)

backend/src/plugins/database.ts (2)
65-73: Add onStop hook to close the database

Ensure clean shutdown in dev/test and production.

Apply:
 export const databasePlugin = new Elysia({ name: 'database', seed: 'database-plugin' })
   .onStart(async () => {
     console.log('Initializing database...')
     const dbPath = process.env.DB_PATH || path.join(Bun.main, '../../dataforge.db')
     await initializeDb(dbPath)
     console.log('Database initialized successfully')
   })
+  .onStop(async () => {
+    await closeDb()
+  })
   .decorate('db', getDb)
57-63: Make closeDb synchronous

closeDb only uses synchronous calls (connection.closeSync()) and doesn’t await anything—remove the async keyword and Promise return type. There is no DuckDBInstance.close() method in the current @duckdb/node-api so instances are only cleaned up via GC (github.com)
backend/tests/api/project/project.get.test.ts (1)
66-69: Fix: Bun.file() has no delete(); use fs.rm

This is likely causing typecheck failure. Prefer Node fs per your docs (“except fs for file operations”).

Apply:
+import { rm, mkdir } from 'node:fs/promises'
@@
   const cleanupTestData = async () => {
@@
-    const tempFilePath = './temp/test-data.json'
-    const tempFile = Bun.file(tempFilePath)
-    await tempFile.delete()
+    const tempFilePath = './temp/test-data.json'
+    await rm(tempFilePath, { force: true })
   }
@@
   const importTestData = async () => {
     const tempFilePath = './temp/test-data.json'
-    await Bun.write(tempFilePath, JSON.stringify(TEST_DATA))
+    await mkdir('./temp', { recursive: true })
+    await Bun.write(tempFilePath, JSON.stringify(TEST_DATA))
backend/src/api/project/index.ts (4)
165-174: On table-exists, clean up created project and return 409

Avoid leaving orphan metadata and use Conflict.
-      if (tableExistsReader.getRows().length > 0) {
-        // await cleanupProject(db, project.id, tempFilePath)
-
-        return status(
-          500,
-          ApiErrorHandler.dataImportErrorWithData(
-            `Table with name 'project_${project.id}' already exists`,
-          ),
-        )
-      }
+      if (tableExistsReader.getRows().length > 0) {
+        await cleanupProject(db, project.id, tempFilePath)
+        return status(
+          409,
+          ApiErrorHandler.tableExistsErrorWithData(`project_${project.id}`),
+        )
+      }
127-137: Ensure temp directory exists before writing/deleting

Bun.write doesn’t create parent dirs; mkdir first. Also deletion should tolerate missing files.
+import { mkdir } from 'node:fs/promises'
+import { resolve } from 'node:path'
@@
-      const tempFilePath = `./temp/${tempFileName}`
+      const tempDir = resolve('./temp')
+      await mkdir(tempDir, { recursive: true })
+      const tempFilePath = `${tempDir}/${tempFileName}`
@@
-      await Bun.file(tempFilePath).delete()
+      try { await Bun.file(tempFilePath).delete() } catch {}
And mirror the same mkdir logic in "/:projectId/import/file" before Bun.write (see below).

Also applies to: 220-222

402-409: Return null body to match 201: t.Null()

Response object breaks the declared schema.
-        // @ts-expect-error ToDo: Fix
-        return status(201, new Response(null))
+        return status(201, null)
371-387: Restrict filePath to the temp directory (path traversal/data exfiltration risk)

User-controlled absolute/relative paths can read arbitrary files. Restrict to ./temp.
-    async ({ db, params: { projectId }, body: { filePath }, status }) => {
-      const fileExists = await Bun.file(filePath).exists()
+    async ({ db, params: { projectId }, body: { filePath }, status }) => {
+      const { resolve, sep } = await import('node:path')
+      const baseDir = resolve('./temp') + sep
+      const resolved = resolve(filePath)
+      if (!resolved.startsWith(baseDir)) {
+        return status(400, ApiErrorHandler.validationError('File path must be within temp directory'))
+      }
+      const fileExists = await Bun.file(resolved).exists()
       if (!fileExists) {
-        return status(400, ApiErrorHandler.fileNotFoundError(filePath))
+        return status(400, ApiErrorHandler.fileNotFoundError(resolved))
       }
@@
-        await db().run(`CREATE TABLE "project_${projectId}" AS SELECT * FROM read_json_auto(?)`, [
-          filePath,
+        await db().run(`CREATE TABLE "project_${projectId}" AS SELECT * FROM read_json_auto(?)`, [
+          resolved,
         ])
backend/src/api/wikibase/index.ts (2)
96-109: Response shape mismatch on properties/search

Handler returns { data: results } but schema declares { data: { results, totalCount, hasMore, query } }.
-      const results = await wikibase.searchProperties(instanceId, q, {
+      const search = await wikibase.searchProperties(instanceId, q, {
         limit,
         offset,
         language,
         languageFallback,
       })
-
-      return { data: results }
+      const { results, totalCount, hasMore } = search
+      return { data: { results, totalCount, hasMore, query: q } }
Also applies to: 110-130

371-389: Response shape mismatch on items/search

Same wrapping issue as properties/search.
-      const results = await wikibase.searchItems(instanceId, q, {
+      const search = await wikibase.searchItems(instanceId, q, {
         limit,
         offset,
         language,
         languageFallback,
       })
-
-      return { data: results }
+      const { results, totalCount, hasMore } = search
+      return { data: { results, totalCount, hasMore, query: q } }
Also applies to: 391-423
backend/src/api/project/project.wikibase.ts (1)
14-151: Rename schema constants to unblock the typecheck

The typecheck failure comes from reusing the same identifier for both the schema value and its exported static type (const TransformationRule + export type TransformationRule = typeof TransformationRule.static). In TypeScript the value and type namespaces collide here, so typeof TransformationRule resolves to the type alias you are defining, producing a duplicate identifier/self-reference error. This repeats for every schema in the file (e.g., ColumnMapping, PropertyReference, WikibaseSchemaResponse, etc.), so the whole file fails to compile. Please rename the schema values (or the exported types) so they differ—for example:
-const TransformationRule = t.Object({
+const TransformationRuleSchema = t.Object({
   type: t.Union([t.Literal('constant'), t.Literal('expression'), t.Literal('lookup')]),
   value: t.String(),
   parameters: t.Optional(t.Record(t.String(), t.Any())),
 })
-export type TransformationRule = typeof TransformationRule.static
+export type TransformationRule = typeof TransformationRuleSchema.static
and then update downstream references to use the renamed schema constant. Apply the same pattern to every other schema/type pair in this file to restore type safety and keep the pipeline green.

🧹 Nitpick comments (16)

backend/src/plugins/database.ts (1)

50-55: getDb throws but guidelines say “NEVER throw”

prompts/Backend.md forbids throwing; align by either guaranteeing initialization before access (derive/decorate a ready connection) or returning a Result-like shape.

As per coding guidelines.

prompts/Backend.md (1)

63-63: Docs vs code: “NEVER throw” conflicts with getDb implementation

Either relax the rule here or adapt getDb to avoid throws to keep docs truthful.

As per coding guidelines.

backend/tests/api/project/project.get.test.ts (2)

157-166: Avoid brittle assertions on validator internals

Hard-coding type: 53 ties you to validator internals. Assert stable fields only.

Apply:

-      {
-        errors: [],
-        message: `Expected string to match '${UUID_REGEX}'`,
-        path: '/projectId',
-        schema: {
-          pattern: UUID_REGEX,
-          type: 'string',
-        },
-        type: 53,
-        value: 'invalid-uuid',
-      },
+      expect.objectContaining({
+        message: expect.stringContaining(UUID_REGEX),
+        path: '/projectId',
+        schema: expect.objectContaining({
+          pattern: UUID_REGEX,
+          type: 'string',
+        }),
+        value: INVALID_UUID,
+      }),

39-47: Optional: stabilize meta expectations

Consider asserting only keys/shape for meta to reduce coupling if pagination metadata evolves.

frontend/src/shared/types/client-errors.ts (1)

35-41: Parameter rename to _message is noisy for public API

Underscore suggests “unused”. Keep message as the param name; map directly.

Apply:

-export const createFrontendError = (
-  code: FrontendErrorCode,
-  _message: string,
-  details?: any[],
-): ExtendedError => ({
-  code,
-  message: _message,
-  details,
-})
+export const createFrontendError = (
+  code: FrontendErrorCode,
+  message: string,
+  details?: any[],
+): ExtendedError => ({
+  code,
+  message,
+  details,
+})

backend/tests/api/project/project.delete.test.ts (1)

75-84: Reduce coupling to validator internals

Same concern as in project.get.test.ts—avoid asserting numeric type code.

Apply:

-      {
-        errors: [],
-        message: `Expected string to match '${UUID_REGEX}'`,
-        path: '/projectId',
-        schema: {
-          pattern: UUID_REGEX,
-          type: 'string',
-        },
-        type: 53,
-        value: 'invalid-uuid-format',
-      },
+      expect.objectContaining({
+        message: expect.stringContaining(UUID_REGEX),
+        path: '/projectId',
+        schema: expect.objectContaining({
+          pattern: UUID_REGEX,
+          type: 'string',
+        }),
+        value: 'invalid-uuid-format',
+      }),

backend/tests/api/project/project.create.test.ts (2)

51-61: Make validation assertions resilient (avoid brittle numeric codes/messages).

type: 54 and the exact message string are internal to TypeBox/Elysia and can change between versions. Assert on stable fields (path, schema constraints, optional value) using partial matchers.

Apply this diff:

-      expect(error).toHaveProperty('value', [
-        {
-          errors: [],
-          message: 'Expected string',
-          path: '/name',
-          schema: {
-            error: 'Project name is required and must be at least 1 character long',
-            minLength: 1,
-            maxLength: 255,
-            type: 'string',
-          },
-          type: 54,
-        },
-      ])
+      expect(error?.value).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            path: '/name',
+            schema: expect.objectContaining({
+              minLength: 1,
+              maxLength: 255,
+              type: 'string',
+            }),
+          }),
+        ]),
+      )

75-85: Same here: assert on stable shape, not internal codes.

Keep value: '' if you want, but drop hard-coded type: 52 and exact message.

Apply this diff:

-        {
-          errors: [],
-          message: 'Expected string length greater or equal to 1',
-          path: '/name',
-          schema: {
-            error: 'Project name is required and must be at least 1 character long',
-            minLength: 1,
-            maxLength: 255,
-            type: 'string',
-          },
-          type: 52,
-          value: '',
-        },
+        expect.objectContaining({
+          path: '/name',
+          value: '',
+          schema: expect.objectContaining({
+            minLength: 1,
+            maxLength: 255,
+            type: 'string',
+          }),
+        }),

backend/src/api/_meta_projects.ts (2)

7-23: Schema looks good; consider stricter types for IDs and timestamps.

Optional but recommended:

Constrain id to UUID with t.String({ format: 'uuid' }) if you’re using OpenAPI/clients.

Constrain dates with t.String({ format: 'date-time' }) if they’re ISO; if space‑separated, keep as is.

I can provide a diff if you confirm the formats you want to expose.

66-74: JSON.parse can throw; guard to prevent 500s from malformed JSON columns.

Wrap parse in try/catch so a single bad row doesn’t break the endpoint.

Apply:
-        jsonColumns.forEach((column) => {
-          if (newRow[column] && typeof newRow[column] === 'string') {
-            newRow[column] = JSON.parse(newRow[column] as string)
-          }
-        })
+        jsonColumns.forEach((column) => {
+          const v = newRow[column]
+          if (typeof v === 'string') {
+            try {
+              newRow[column] = JSON.parse(v)
+            } catch {
+              // leave as-is if parsing fails
+            }
+          }
+        })

backend/src/api/wikibase/schemas.ts (1)

53-76: Bound pagination inputs to protect the service

Cap limit and validate offset to avoid heavy scans.

-  limit: t.Number({
-    default: 10,
-    description: 'Maximum number of results',
-  }),
-  offset: t.Number({
-    default: 0,
-    description: 'Offset for pagination',
-  }),
+  limit: t.Number({
+    default: 10,
+    min: 1,
+    max: 100,
+    description: 'Maximum number of results',
+  }),
+  offset: t.Number({
+    default: 0,
+    min: 0,
+    description: 'Offset for pagination',
+  }),

backend/src/api/wikibase/index.ts (1)

241-266: Validate property route: context should be optional; otherwise callers must always send it

If intentional, ignore. Otherwise, make context optional.

-      body: t.Object({
+      body: t.Object({
         propertyId: PropertyId,
         value: t.Any({
           description: 'Value to validate against property constraints',
         }),
-        context: t.Object({
+        context: t.Optional(t.Object({
           entityId: t.Optional(
             t.String({
               description: 'Entity ID for context',
             }),
           ),
           additionalProperties: t.Optional(
             t.Array(
               t.Object({
                 property: t.String(),
                 value: t.Any(),
               }),
             ),
           ),
-        }),
+        })),

Also applies to: 267-299

backend/tests/api/project/project.wikibase.test.ts (3)

33-47: Trim object churn in label builder.

Avoid repeated Object.assign and mutable let; build in one pass with a reducer.

-const deterministicLabels = (count = 2): Label => {
-  let labels: Label = {}
-  for (let i = 0; i < count; i++) {
-    const lang = deterministicLang(i)
-    labels = Object.assign({}, labels, {
-      [lang]: {
-        columnName: deterministicString('Label'),
-        dataType: 'monolingualtext',
-      },
-    } as Label)
-  }
-  return labels
-}
+const deterministicLabels = (count = 2): Label =>
+  Array.from({ length: count }, (_, i) => deterministicLang(i)).reduce<Label>((acc, lang) => {
+    acc[lang] = { columnName: deterministicString('Label'), dataType: 'monolingualtext' }
+    return acc
+  }, {} as Label)

49-63: Mirror the same simplification for descriptions.

-const deterministicDescriptions = (count = 2): Label => {
-  let descriptions: Label = {}
-  for (let i = 0; i < count; i++) {
-    const lang = deterministicLang(i)
-    descriptions = Object.assign({}, descriptions, {
-      [lang]: {
-        columnName: deterministicString('Description'),
-        dataType: 'monolingualtext',
-      },
-    })
-  }
-  return descriptions
-}
+const deterministicDescriptions = (count = 2): Label =>
+  Array.from({ length: count }, (_, i) => deterministicLang(i)).reduce<Label>((acc, lang) => {
+    acc[lang] = { columnName: deterministicString('Description'), dataType: 'monolingualtext' }
+    return acc
+  }, {} as Label)

65-81: And for aliases, build immutably.

-const deterministicAliases = (count = 2): Alias => {
-  let aliases: Alias = {}
-  for (let i = 0; i < count; i++) {
-    const lang = deterministicLang(i)
-    aliases = Object.assign({}, aliases, {
-      [lang]: [
-        {
-          columnName: deterministicString('Alias'),
-          dataType: 'monolingualtext',
-        },
-      ],
-    })
-  }
-  return aliases
-}
+const deterministicAliases = (count = 2): Alias =>
+  Array.from({ length: count }, (_, i) => deterministicLang(i)).reduce<Alias>((acc, lang) => {
+    acc[lang] = [{ columnName: deterministicString('Alias'), dataType: 'monolingualtext' }]
+    return acc
+  }, {} as Alias)

backend/src/api/project/schemas.ts (1)

22-25: Prefer integer defaults for pagination (optional).

If offsets must be integers, consider t.Integer({ default: 0 }) and t.Integer({ default: 25 }) for stricter validation.
-export const PaginationQuery = t.Object({
-  offset: t.Number({ default: 0 }),
-  limit: t.Number({ default: 25 }),
-})
+export const PaginationQuery = t.Object({
+  offset: t.Integer({ default: 0 }),
+  limit: t.Integer({ default: 25 }),
+})

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 163eb3c and 2423772.

⛔ Files ignored due to path filters (1)

bun.lock is excluded by !**/*.lock

📒 Files selected for processing (22)

backend/package.json (1 hunks)
backend/src/api/_meta_projects.ts (2 hunks)
backend/src/api/project/import.ts (0 hunks)
backend/src/api/project/index.ts (8 hunks)
backend/src/api/project/project.wikibase.ts (7 hunks)
backend/src/api/project/schemas.ts (1 hunks)
backend/src/api/wikibase/index.ts (10 hunks)
backend/src/api/wikibase/schemas.ts (1 hunks)
backend/src/index.ts (0 hunks)
backend/src/plugins/database.ts (1 hunks)
backend/src/types/error-schemas.ts (1 hunks)
backend/src/types/wikibase-schema.ts (1 hunks)
backend/tests/api/project/project.create.test.ts (2 hunks)
backend/tests/api/project/project.delete.test.ts (2 hunks)
backend/tests/api/project/project.get.test.ts (2 hunks)
backend/tests/api/project/project.wikibase.test.ts (17 hunks)
frontend/package.json (1 hunks)
frontend/src/shared/types/client-errors.ts (1 hunks)
guidelines/reference/ELYSIA_EDEN.md (1 hunks)
package.json (1 hunks)
prompts/Backend.md (2 hunks)
prompts/Frontend.md (1 hunks)

💤 Files with no reviewable changes (2)

backend/src/index.ts
backend/src/api/project/import.ts

🧰 Additional context used

🧬 Code graph analysis (8)

backend/tests/api/project/project.delete.test.ts (1)

backend/src/api/project/schemas.ts (1)

UUID_REGEX (4-5)

frontend/src/shared/types/client-errors.ts (1)

frontend/auto-imports.d.ts (1)

ExtendedError (386-386)

backend/tests/api/project/project.wikibase.test.ts (2)

backend/src/api/project/project.wikibase.ts (4)

Label (91-91)

Alias (95-95)

wikibaseRoutes (160-365)

WikibaseCreateSchema (150-150)

backend/src/plugins/database.ts (1)

databasePlugin (65-72)

backend/src/api/project/index.ts (2)

backend/src/api/project/schemas.ts (3)

ProjectResponseSchema (13-18)

PaginationQuery (22-25)

ResponseSchema (41-50)

backend/src/types/error-schemas.ts (2)

ApiErrors (20-26)

ApiErrors (27-27)

backend/src/api/project/project.wikibase.ts (4)

backend/src/types/wikibase-schema.ts (8)

PropertyId (11-16)

PropertyId (17-17)

WikibaseDataType (26-37)

WikibaseDataType (38-38)

StatementRank (19-23)

StatementRank (24-24)

ItemId (3-8)

ItemId (9-9)

backend/src/api/project/schemas.ts (1)

UUIDPattern (9-11)

backend/src/api/wikibase/schemas.ts (1)

InstanceId (48-51)

backend/src/types/error-schemas.ts (2)

ApiErrors (20-26)

ApiErrors (27-27)

backend/src/api/wikibase/schemas.ts (2)

backend/src/types/wikibase-schema.ts (2)

WikibaseDataType (26-37)

WikibaseDataType (38-38)

backend/src/types/wikibase-api.ts (1)

PropertySearchResult (84-93)

backend/tests/api/project/project.get.test.ts (1)

backend/src/api/project/schemas.ts (1)

UUID_REGEX (4-5)

backend/src/api/wikibase/index.ts (3)

backend/src/api/wikibase/schemas.ts (7)

InstanceId (48-51)

OAuthCredentials (4-17)

OAuthCredentials (18-18)

QuerySchema (53-76)

PropertySearchResultSchema (32-45)

Term (29-29)

Term (30-30)

backend/src/types/error-schemas.ts (2)

ApiErrors (20-26)

ApiErrors (27-27)

backend/src/types/wikibase-schema.ts (6)

PropertyId (11-16)

PropertyId (17-17)

WikibaseDataType (26-37)

WikibaseDataType (38-38)

ItemId (3-8)

ItemId (9-9)

🪛 GitHub Actions: Typecheck code

backend/src/plugins/database.ts