DEV Community: Jay-Em

I Built an ORM That Starts With JSON So You Can Stop Overthinking Your Database

Jay-Em — Thu, 19 Feb 2026 03:36:05 +0000

You know that thing where you have a project idea at 1am, you're hyped, and then you spend the next 2 hours setting up Postgres, writing migrations, configuring connection strings, and by the time you're done your motivation is gone and you go to bed?

Yeah. That kept happening to me. So I built something about it.

What is SeedORM?

SeedORM is a Node.js ORM that stores everything in local JSON files. No database server, no Docker, no connection strings. You define your models and start building immediately.

Then when your project is ready for the real world, you migrate to Postgres with one command. Same models, same queries, same API. Nothing changes except where the data lives.

npm install seedorm

The Problem

Every side project I start follows the same pattern:

Cool idea hits me
Create new folder, npm init
Okay now I need a database
Do I use Postgres? MongoDB? SQLite?
Spend 30 minutes setting up Docker, env vars, connection pooling
Write migration files
I'm tired now
Abandon project

I wanted something where step 3 is just... skip.

How It Works

Define your models like you normally would:

import { SeedORM, FieldType } from "seedorm";

const db = new SeedORM();
await db.connect();

const User = db.model({
  name: "users",
  fields: {
    name: { type: FieldType.String, required: true },
    email: { type: FieldType.String, unique: true },
    age: { type: FieldType.Number },
  },
});

await User.init();

That's it. No database running. No config file pointing to localhost:5432. It just writes to JSON files in a data/ folder.

Now use it like any ORM:

// Create
const user = await User.create({ name: "Josh", email: "josh@hey.com", age: 24 });

// Query
const adults = await User.find({ filter: { age: { $gte: 18 } } });

// Update
await User.update(user.id, { age: 25 });

// Delete
await User.delete(user.id);

Relations

It supports the relation types you'd expect:

const Post = db.model({
  name: "posts",
  fields: {
    title: { type: FieldType.String, required: true },
    body: { type: FieldType.String },
  },
  relations: {
    author: {
      type: "belongsTo",
      model: "users",
      foreignKey: "authorId",
    },
  },
});

hasMany, belongsTo, manyToMany. They all work the same way when you eventually switch to Postgres.

The Studio

I got tired of opening JSON files to check my data, so I built a visual browser for it. Run seedorm studio and you get a web UI at localhost:4200 where you can browse collections, search across fields, paginate through documents, and edit records.

It's nothing fancy. It's just nice to have when you're building and want to see what's in your database without writing a query.

Per-Collection File Storage

One thing that bugged me early on was that everything was stored in a single seedorm.json file. With a few thousand documents across multiple collections, that file gets massive.

So now each collection gets its own file:

data/
  users.json
  posts.json
  comments.json

Each file is minified (single line), writes only happen for collections that changed, and if you have an old seedorm.json from a previous version it auto-migrates on startup. You don't have to do anything.

When You're Ready for Postgres

Your project took off. Congrats. Time for a real database.

seedorm migrate to postgres

Your models stay the same. Your queries stay the same. You just change the adapter config:

const db = new SeedORM({
  adapter: {
    adapter: "postgres",
    url: "postgresql://localhost:5432/myapp",
  },
});

That's the whole point. Build fast with JSON, switch when it matters.

What It's NOT

Let me be clear about what SeedORM is not:

It's not a Prisma replacement for your production app with 10 million users
It's not meant for high-concurrency workloads
It's not trying to be the last ORM you'll ever use

It's for prototyping, side projects, hackathons, and that 1am idea that deserves to exist without a 30 minute setup ritual.

Try It

npm install seedorm

GitHub
npm

If you try it, I'd genuinely love to hear what you think. What's missing? What's annoying? What would make you actually use this?

Thanks for reading.

Dart Extensions: Unleashing the Power of Your Code! 🚀

Jay-Em — Sat, 18 May 2024 02:04:50 +0000

Hello everyone! Welcome to another exciting post. I hope you'll find this one just as useful!! Arigatogozaimasuuu! 🎉

Have you ever felt limited by the built-in methods in Dart? Ever wished you could add your own methods to existing classes? Well, you're in luck because today I'm going to show you how to harness the magic of Dart extensions! 🌟

Extensions allow you to add new functionality to existing libraries. They're a game-changer for making your code cleaner and more readable. Let's dive right in!

Prerequisites

Dart SDK
A Dart project setup

Getting Started with Dart Extensions

First things first, make sure you have Dart installed. If you don't, you can download it from Dart's official website.

Creating Your First Extension

Let's say you want to add a new method to the String class. Here's how you can do it:

Open your Dart project and create a new file called string_extensions.dart.
Inside string_extensions.dart, add the following code:

extension StringExtensions on String {
  bool isPalindrome() {
    return this == this.split('').reversed.join('');
  }
}

What did we just do? We created an extension on the String class that adds a method called isPalindrome. This method checks if a string reads the same backward as forward. Cool, right? 😎

Using Your Extension

Now, let's use this new method in our project.

Import your extension into your main Dart file:

import 'string_extensions.dart';

Use the new method on any string:

void main() {
  String word = 'level';
  print('Is "$word" a palindrome? ${word.isPalindrome()}');
}

Run your Dart program, and you should see the output:

Is "level" a palindrome? true

Boom! You've just extended the String class with a custom method. 🚀

More Practical Examples

Let's explore some more practical examples to get you comfortable with extensions.

Example 1: Adding a `toCapitalized` Method

Sometimes you might need to capitalize the first letter of a string. Let's create an extension for that.

extension CapitalizedString on String {
  String toCapitalized() {
    return this.length > 0 ? '${this[0].toUpperCase()}${this.substring(1)}' : '';
  }
}

Example 2: Adding a `num` Extension

You can also extend numeric types. Let's add a method to double a number.

extension NumExtensions on num {
  num doubled() {
    return this * 2;
  }
}

Using the New Extensions

Don't forget to import your extensions and use them in your code:

import 'string_extensions.dart';

void main() {
  String name = 'dart';
  print('Capitalized: ${name.toCapitalized()}');

  num value = 42;
  print('Doubled: ${value.doubled()}');
}

Conclusion

That's it! You've just learned how to create and use Dart extensions to make your code more powerful and expressive. 🎉

Extensions are a fantastic way to add custom functionality to existing classes without modifying their source code. Use them wisely to keep your code clean and maintainable.

I hope you've enjoyed this post and found it useful. Stay tuned for more exciting content! 🚀

Auto update React app in Heroku upon git push on GitHub

Jay-Em — Sat, 16 Jul 2022 12:28:45 +0000

Hello everyone! This is going to be my first ever post here. I hope you'll find this useful!! Arigatogozaimasuuu!

Update: Heroku is not free anymore, these tutorial is outdated and will be updated soon

Have you ever wondered if it is possible to just push your application update in your Github repo and then it will auto re-deploy your app in Heroku? Well, stop wondering because today I will share you the process on how to setup one in your React app project and save you the hassle of searching it on your own!

We will utilize the use of what we call, "the magical" Github Actions. This is the main key that will unlock the possibility on how to make this idea come true.

I will assume that you already know how to create a Github repo, create an application in Heroku, and know the basics of Git. With that in mind, let us now start doing it!

Prerequisites

Setting up Github and Heroku

1) First, you need to create a Github repository and push your React project there. In my case, I just pushed the default React app created by using npx create-react-app.
2) After that, you can now create an app in Heroku. Just leave the tabs open for the moment ;)

Setting up your React app

3) Now in your project's root directory, create a new folder or a directory if that's what you want to call it, name it as server and then create a new file inside naming app.js and paste this code.

const path = require('path');
const express = require('express');
const port = process.env.PORT || 3000;
const app = express();

const publicPath = path.join(__dirname, '..', 'build');
app.use(express.static(publicPath));

app.get('*', (req, res) => {
res.sendFile(path.join(publicPath, 'index.html'));
}); 

app.listen(port, () => {
console.log(`Server is up on port ${port}!`);
});

What in the world does this code do? Well, if you read it carefully, it's just serving your app's public folder to the browser.

4) The project should look something like this.

5) Now open your favorite terminal, navigate inside the server directory of your React app, and initiate node.js by

npm init --y

6) Now from here, I recommend using yarn, and then install express.js by

yarn add express

7) After installing express you should probably add a .gitignore file containing node_modules inside. You don't want to push it in Heroku because of its massive size. It should look like this.

8) Navigate back to our project's root directory and create a Procfile file and paste this inside

web: node ./server/app.js

It should now look something like this.

Setting up the Github action

9) After adding that, open a new terminal and login to Heroku by typing

heroku login

If heroku is unknown to your system, you should install the Heroku cli first. It will open a login prompt in your browser. Just follow the instructions there and if it works, you should see something like this.

10) After successfully logging in, switch back to your previous terminal or open a new one and navigate back to your project's root directory. Commit all of your changes to your local branch, and add a remote branch for Heroku by typing in

heroku git:remote -a [name of your app]

It should look like this.

11) Now push your React app to Heroku by typing

git push heroku [your master branch]

My master branch is main so it should look like this.

12) After pushing it to Heroku successfully, from your project's root directory, create a new directory following this structure.

13) In the newly created file main.yml, paste this code inside.

name: Deploy

on:
  push:
    branches:
      - [gitmainbranch]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: akhileshns/heroku-deploy@v3.12.12 # This is the action
        with:
          heroku_api_key: ${{secrets.HEROKU_API_KEY}}
          heroku_app_name: "[herokuappname]" #Must be unique in Heroku
          heroku_email: "[emailloggedinheroku]"

Replace [gitmainbranch] with your master branch or main branch.
Replace [herokuappname] with your Heroku app name.
Replace [emailloogedinheroku] with the email you use in your Heroku account.

This code is just a simple Github workflow that tells Github to auto update Heroku upon changes in the main branch of your React application.

With my setup, it should look like this.

14) In your Heroku account, go to account settings and reveal your API key, and guess what? Copy it.

15) In your Github repo, go to your repository settings and add a new secret named HEROKU_API_KEY and paste the API key you copied from Heroku.

16) We're almost done!!! Now save all files, commit all the changes and push it to your Github repo by

git push origin main

It should be something like this.

You're done! Congrats!

17) Hooray!! We're done! Try making some changes in your app and push it on Github repo by

git push origin main

or by merging a certain branch to your master branch. This action will be triggered whenever there's a change in your master branch. Once you've pushed a change, you'll see something like this in your action tab.

You'll also gonna see the logs in your Heroku app

Thanks!

That's it! You have now successfully setup your Github-Heroku workflow that will auto update your deployed React app on the go.
I hope you've liked my first content here at DEV! I will post more in the future! Please see my website to know me more! Thanks!

DEV Community: Jay-Em

I Built an ORM That Starts With JSON So You Can Stop Overthinking Your Database

What is SeedORM?

The Problem

How It Works

Relations

The Studio

Per-Collection File Storage

When You're Ready for Postgres

What It's NOT

Try It

Dart Extensions: Unleashing the Power of Your Code! 🚀

Prerequisites

Getting Started with Dart Extensions

Creating Your First Extension

Using Your Extension

More Practical Examples

Example 1: Adding a toCapitalized Method

Example 2: Adding a num Extension

Using the New Extensions

Conclusion

Auto update React app in Heroku upon git push on GitHub

Prerequisites

Setting up Github and Heroku

Setting up your React app

Setting up the Github action

You're done! Congrats!

Thanks!

Example 1: Adding a `toCapitalized` Method

Example 2: Adding a `num` Extension