# What Is the Primary Programming Language Used in the oblien/openship Repository?

> Discover the primary programming language of the oblien/openship repository. Learn how TypeScript powers both server-side logic and React components for efficient development.

- Repository: [oblien/openship](https://github.com/oblien/openship)
- Tags: getting-started
- Published: 2026-07-29

---

**The oblien/openship repository is built almost entirely with TypeScript, including both `.ts` files for server-side logic and `.tsx` files for React components.**

The openship platform is a modern monorepo that leverages TypeScript as its foundational programming language to ensure type safety across database clients, dashboard utilities, and UI components. While auxiliary JavaScript files exist for tooling scripts, the executable application code, configuration, and component architecture are implemented using TypeScript’s strict typing system. This choice enables robust development practices across the workspace’s packages and applications, from the database layer to the frontend interface.

## TypeScript Configuration Across the Monorepo

The repository’s commitment to TypeScript begins at the root level with a [`tsconfig.base.json`](https://github.com/oblien/openship/blob/main/tsconfig.base.json) file that defines compiler options for the entire workspace. This centralized configuration ensures consistent type checking and module resolution across all sub-projects.

Individual packages maintain their own TypeScript configurations to handle specific requirements. For example, the **db** package contains [`packages/db/tsconfig.json`](https://github.com/oblien/openship/blob/main/packages/db/tsconfig.json) to manage database client types, while the **ui** package uses [`packages/ui/tsconfig.json`](https://github.com/oblien/openship/blob/main/packages/ui/tsconfig.json) for component library compilation. The main web application reinforces this pattern with [`apps/web/tsconfig.json`](https://github.com/oblien/openship/blob/main/apps/web/tsconfig.json), confirming that TypeScript serves as the primary language for both shared libraries and end-user applications.

## Server-Side TypeScript Implementation

Core business logic and utility functions are written in standard `.ts` files with strict typing. In [`packages/db/src/client.ts`](https://github.com/oblien/openship/blob/main/packages/db/src/client.ts), the database client exports a typed query wrapper that leverages TypeScript generics for result sets:

```typescript
// packages/db/src/client.ts – a simple Postgres client wrapper
import { Pool } from 'pg';

export const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

export async function query<T>(sql: string, params?: any[]): Promise<T[]> {
  const { rows } = await pool.query<T>(sql, params);
  return rows;
}

```

Similarly, dashboard utilities such as [`apps/dashboard/src/utils/deploymentPhaseDetector.ts`](https://github.com/oblien/openship/blob/main/apps/dashboard/src/utils/deploymentPhaseDetector.ts) demonstrate TypeScript’s use in operational logic, where type safety prevents runtime errors in deployment workflows.

## TSX and React Frontend Development

The frontend layer utilizes **TSX** (TypeScript XML) to combine React’s component model with static type checking. UI components enforce props interfaces, ensuring that developers catch mismatches during compilation rather than at runtime.

A representative example from the dashboard utilities illustrates this pattern:

```tsx
// apps/dashboard/src/utils/ui-helpers.tsx – a React component written in TSX
import React from 'react';

type ButtonProps = {
  label: string;
  onClick: () => void;
};

export const PrimaryButton: React.FC<ButtonProps> = ({ label, onClick }) => (
  <button className="bg-blue-600 text-white py-2 px-4 rounded" onClick={onClick}>
    {label}
  </button>
);

```

This approach pervades the `apps/dashboard` and `apps/web` directories, where `.tsx` files handle view rendering with fully typed props and state management.

## Auxiliary JavaScript Files and Tooling

While TypeScript dominates the application code, the repository contains minimal **JavaScript** (`.js`) and ECMAScript module (`.mjs`) files. These are restricted to build scripts, tooling configurations, or legacy compatibility layers that do not require the type safety guarantees of the main application stack. The overwhelming ratio of `.ts` and `.tsx` files to JavaScript confirms TypeScript’s role as the primary implementation language.

## Summary

- **TypeScript** is the primary programming language in oblien/openship, used for both server logic and React components.
- The root [`tsconfig.base.json`](https://github.com/oblien/openship/blob/main/tsconfig.base.json) and package-level [`tsconfig.json`](https://github.com/oblien/openship/blob/main/tsconfig.json) files enforce type safety across the monorepo.
- Key files like [`packages/db/src/client.ts`](https://github.com/oblien/openship/blob/main/packages/db/src/client.ts) demonstrate strongly typed database interactions using generics.
- **TSX** files in [`apps/dashboard/src/utils/ui-helpers.tsx`](https://github.com/oblien/openship/blob/main/apps/dashboard/src/utils/ui-helpers.tsx) and similar paths enable type-safe React development.
- Auxiliary JavaScript exists only for tooling, while executable code remains strictly TypeScript.

## Frequently Asked Questions

### Is the oblien/openship repository written entirely in TypeScript?

No, while the vast majority of application code is written in TypeScript and TSX, the repository contains a small number of JavaScript and `.mjs` files used for build scripts and tooling automation. The core logic, database clients, and React components are exclusively TypeScript.

### What role does the [`tsconfig.base.json`](https://github.com/oblien/openship/blob/main/tsconfig.base.json) file play in the openship repository?

The [`tsconfig.base.json`](https://github.com/oblien/openship/blob/main/tsconfig.base.json) file at the repository root defines the foundational compiler options and type-checking rules for the entire monorepo. Package-specific configurations like [`packages/db/tsconfig.json`](https://github.com/oblien/openship/blob/main/packages/db/tsconfig.json) and [`packages/ui/tsconfig.json`](https://github.com/oblien/openship/blob/main/packages/ui/tsconfig.json) extend this base to customize settings for their respective domains while maintaining workspace consistency.

### Does openship use TypeScript for both frontend and backend code?

Yes, the codebase uses TypeScript (`.ts`) for server-side utilities and database clients such as [`packages/db/src/client.ts`](https://github.com/oblien/openship/blob/main/packages/db/src/client.ts), and TSX (`.tsx`) for React components in the dashboard and web applications. This unified language choice enables shared type definitions across the full stack.

### How does TypeScript improve development in the openship monorepo?

TypeScript provides compile-time type checking that prevents runtime errors in critical paths like database queries and UI component rendering. The strict configuration enforced across [`apps/web/tsconfig.json`](https://github.com/oblien/openship/blob/main/apps/web/tsconfig.json) and related files ensures that type safety standards apply consistently from the database layer through to the frontend interface.