Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/sweetiq/schemats
Generate typescript interface definitions from SQL database schema
https://github.com/sweetiq/schemats
automation mysql postgres postgresql reflection schema typescript
Last synced: 16 days ago
JSON representation
Generate typescript interface definitions from SQL database schema
- Host: GitHub
- URL: https://github.com/sweetiq/schemats
- Owner: SweetIQ
- License: mit
- Created: 2016-08-15T17:54:26.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2022-01-06T15:13:34.000Z (almost 3 years ago)
- Last Synced: 2024-10-12T11:06:07.743Z (25 days ago)
- Topics: automation, mysql, postgres, postgresql, reflection, schema, typescript
- Language: TypeScript
- Homepage: https://www.npmjs.com/package/schemats
- Size: 1.14 MB
- Stars: 1,034
- Watchers: 22
- Forks: 102
- Open Issues: 49
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
# Schemats
[](https://www.npmjs.com/package/schemats)
[](https://github.com/SweetIQ/schemats)
[](https://travis-ci.org/SweetIQ/schemats)
[](https://coveralls.io/github/SweetIQ/schemats?branch=coverage)
Using Schemats, you can generate TypeScript interface definitions from (Postgres, MySQL) SQL database schema automatically.
Start with a database schema:
Users
idSERIAL
usernameVARCHAR
passwordVARCHAR
last_logonTIMESTAMP
Automatically have the following TypesScript Interface generated
```typescript
interface Users {
id: number;
username: string;
password: string;
last_logon: Date;
}
```
For an overview on the motivation and rational behind this project, please take a look at [Statically typed PostgreSQL queries in Typescript
](http://cs.mcgill.ca/~mxia3/2016/11/18/Statically-typed-PostgreSQL-queries-and-typescript-schemats/).
## Quick Start
### Installing Schemats
```
npm install -g schemats
```
### Generating the type definition from schema
```
schemats generate -c postgres://postgres@localhost/osm -t users -o osm.ts
schemats generate -c mysql://mysql@localhost/osm -t users -o osm.ts
```
The above commands will generate typescript interfaces for [`osm`](test/osm_schema.sql) database
with table [`users`](test/osm_schema.sql#L18). The resulting file is stored as [`osm.ts`](test/example/osm.ts).
### Generating the type definition for all the tables in a postgres schema
To generate all type definitions for all the tables within the schema 'public':
*Note: MySQL does not have a default public schema, but should it have a schema named public, this will still work.*
```
schemats generate -c postgres://postgres@localhost/osm -s public -o osm.ts
schemats generate -c mysql://mysql@localhost/osm -s public -o osm.ts
```
If neither the table parameter nor the schema parameter is provided, all tables in schema 'public' will be generated, so the command above is equivalent to:
```
schemats generate -c postgres://postgres@localhost/osm -o osm.ts
schemats generate -c mysql://mysql@localhost/osm -o osm.ts
```
### Using schemats.json config file
Schemats supports reading configuration from a json config file (defaults to `schemats.json`). Instead of passing configuration via commandline parameter like done above, it is also possible to supply the configuration through a config file. The config file supports the same parameters as the commandline arguments.
For example, if a `schemats.json` exists in the current working directory with the following content:
```json
{
"conn": "postgres://postgres@localhost/osm",
"table": ["users"]
}
```
Running `schemats generate` here is equivalent to running `schemats generate -c postgres://postgres@localhost/osm -t users -o osm.ts`.
### Writing code with typed schema
We can import `osm.ts` directly
```typescript
// imports the _osm_ namespace from ./osm.ts
import * as osm from './osm'
// Now query with pg-promise and have a completely typed return value
let usersCreatedAfter2013: Array
= await db.query("SELECT * FROM users WHERE creation_time >= '2013-01-01'");
// We can decide to only get selected fields
let emailOfUsersCreatedAfter2013: Array<{
email: osm.users['email'],
creation_time: osm.users['creation_time']
}> = await db.query("SELECT (email, creation_time) FROM users WHERE creation_time >= '2013-01-01'");
```
With generated type definition for our database schema, we can write code with autocompletion and static type checks.
### Using schemats as a library
Schemats exposes two high-level functions for generating typescript definition from a database schema. They can be used by a build tool such as grunt and gulp.
### Upgrading to v1.0
#### Deprecation of Namespace
Version 1.0 deprecates generating schema typescript files with namespace.
Instead of generating schema typescript files with
```bash
schemats generate -c postgres://postgres@localhost/db -n yournamespace -o db.ts
```
and import them with
```typescript
import {yournamespace} from './db'
```
It is now encouraged to generate without namespace
```bash
schemats generate -c postgres://postgres@localhost/db -o db.ts
```
and import them with
```typescript
import * as yournamespace from './db'
// or
import {table_a, table_b} from './db'
```
As [TypeScript's documentation](https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html) describes,
having a top level namespace is needless. This was discussed in [#25](https://github.com/SweetIQ/schemats/issues/25).
Generating schema typescript files with namespace still works in v1.0, but it is discouraged and subjected to
removal in the future.
#### Support Strict Null-Checking
Version 1.0 [supports](https://github.com/SweetIQ/schemats/issues/19)
[strict null-checking](https://github.com/Microsoft/TypeScript/pull/7140)
and reflects the _NOT NULL_ constraint defined in PostgreSQL schema.