DEV Community: Abderrahmene Merzoug

I Got Tired of APIs, So I Built a New Vue Framework

Abderrahmene Merzoug — Mon, 28 Jul 2025 15:37:51 +0000

Hey everyone,

I want to share a project I've been passionately working on called Fictif. It's a full-stack Vue 3 framework born from
my own frustration with the modern web development workflow.

Github Repo

The Pain Point: The "API Chasm"

I love building with backend frameworks like Laravel or AdonisJS. The routing, controllers, and ORM are just so productive. But I also love the fluid, app-like user experience you get with a Vue SPA.

The problem has always been the gap between the two worlds. To connect them, you have to build and maintain a whole separate thing: a REST or GraphQL API.

Suddenly, you're juggling two sets of routes, two validation layers, and complex state management on the frontend to handle data fetching, loading states, and errors. It felt like I was building two separate applications instead of one.

I looked at tools like Nuxt, but I didn't want to be locked into a Node.js server. I looked at Inertia.js, and I liked the idea, but I felt the client-side tooling could be so much more powerful and integrated.

So, I decided to build the framework I always wanted.

Introducing Fictif: The Best of Both Worlds

Fictif lets you build a modern, reactive single-page application with Vue, but your backend controllers drive the UI directly. No API required.

You just return a view and some data from your backend controller, and Fictif intelligently renders the right Vue component on the frontend. It's that simple.

What Makes Fictif Different?

Fictif isn't just an adapter; it's a complete, "batteries-included" framework for your frontend.

⚡️ Zero-Config Code Splitting: Your page components (*.screen.vue) are automatically discovered and lazy-loaded. Your app is fast by default.
📋 Powerful Form Handling: It comes with a useForm composable that handles data, validation errors, file uploads, and submission states right out of the box. Look how clean this is:

<!-- contact.screen.vue -->
<script setup>
import { useForm } from 'fictif';

const form = useForm({ name: '', email: '', message: '' });

// form.post('/contact') handles everything, including error mapping.
</script>
<template>
  <form @submit.prevent="form.post('/contact')">
    <input v-model="form.name" />
    <div v-if="form.errors.name">{{ form.errors.name }}</div>

    <input v-model="form.email" />
    <div v-if="form.errors.email">{{ form.errors.email }}</div>

    <button :disabled="form.processing">Send</button>
  </form>
</template>

✨ A Full Toolkit: It includes a Head manager for SEO, a powerful API client for when you do need one, automatic loading indicators, and more. It’s a complete system where all the pieces are designed to work together.

I'd Love Your Feedback!

This project is still young, but it's born from a real-world need to build better, faster, and more maintainable web apps. I truly believe this "server-driven SPA" approach is a more productive way to work for many of us.

If this sounds interesting to you, I'd be incredibly grateful if you could check it out.

Live Demo: [link-to-your-live-demo]
GitHub Repo (with Starter Kit link): [link-to-your-github-repo]
Full Documentation: [link-to-your-gitbook]

What do you think? Does this solve a problem you've faced? Are there features you think are missing?

Let me know in the comments below! Thanks for reading.

Fictif | An application framework for building modern, server-driven web apps with Vue 3

Abderrahmene Merzoug — Fri, 25 Jul 2025 14:18:03 +0000

GitHub Repo
NPM Package

What is Fictif?

Fictif is a full-stack application framework for building modern, server-driven web apps with Vue 3 — without needing to maintain a separate frontend API. It blends the power of classic server-side tools like Laravel with the speed of SPAs, offering a flexible, composable alternative to Inertia.js, Nuxt, and Vue Router.

Whether you're building Laravel hybrids, Electron apps, PWAs, or fully client-side SPAs, Fictif adapts effortlessly — with zero runtime dependencies and a tiny footprint.

Features

Auto Screen Discovery: You dont have to import all of your (pages/screens) to use them, all vue files that end with *.screen.vue, and are placed in resources/screens, are discovered, and defined with a path like this: path.to.welcome for resources/screens/path/to/welcome.screen.vue, the screen resolver has many other features like node_packages and vendor discovery (vendor::has.a.screen) and overrides that i will document later
Hybrid by Default: Get the best of both worlds. Build with server-side routing and controllers, but deliver a seamless, app-like experience to your users, or implement a client-side routing directly to your code.
Batteries Included: Ships with high-quality, unstyled components like <Display>, <Curtain>, and <MultiStep> to accelerate development.
Truly Composable API: A complete suite of Vue 3 composables (useRouter, useForm, useScreens, useHead) that provide a powerful and intuitive developer experience.
Minimal Dependencies: This package has zero runtime dependencies to be bundled with your built code, it uses a single dependency to help with screen resolving. namely fast-glob during development only.
Written in typescript: You can understand the usage just by looking at the code, IDE's like vscode will understand the package.
Secure & Performant: A tiny, dependency-free client, build-time route obfuscation, and first-class support for modern web security practices.

Documentation

We are currently writing documentation for this library, we will cover basic usage here.

Installation

This package is in its early beta version, we recommend not to use it in production environments, you can install the latest GitHub release:

pnpm i fictifhq/fictif#release
# or use npm

Or get stable releases from npm registry:

pnpm i fictif
# or use npm

Usage

For inertia-like usage, scroll down.
Let's get straight to the point,

Add this to your vite.config.js


export default defineConfig({
    plugins: [
        vue(), // ... and other plugins you already have
        fictif()
    ],
});

Your project structure should look like:

resources/
    js/
        app.js
        ... Your javascript files
    css/
        ... Your css files
    screens/
        welcome.page.vue
        ... Your views ( screens )

import { createFictifApp } from 'fictif'
import 'fictif/style'

createFictifApp((route) => {
        route.get('/', (req) => {
            return view('welcome').with({
                // You can pass props here
                abcd: '2025'
            })
        });

        route.get('/:someArg', (req, someArg) => {
            return view('welcome').with({
                abcd: someArg
            })
        });

        // This is how to handle 404
        //route.get('*', (req, arg1) => {
        //    //
        //});
    });

<template>
    Hello {{ abcd }}
</template>

<script>
    const { abcd } = defineProps(['abcd']);
</script>

That's all 🧨

Inertia-like Usage

If you have an inertiajs compatible backend, like laravel with inertia installed, do this in your app.js

import { createFictifApp } from 'fictif'
import 'fictif/style'

createFictifApp();

// Theres plenty of things to customize, don't worry, i will document all of them soon.

Yep, thats all, you can define your screens in resources/screens, dont forget to add the fictif() vite plugin.

Core Concepts

useRouter() & Events

The router is the heart of Fictif. It manages the visit lifecycle with a granular event system.

import { useRouter } from 'fictif';

const router = useRouter(); // Get the globally initialized router

// Listen to lifecycle events
router.on('leaving', () => {
    if (hasUnsavedChanges()) {
        if (!confirm("Leave without saving?")) {
            router.preventNavigation();
        }
    }
});

router.on('navigation', () => progress.start());
router.on('navigated', () => progress.finish());
router.on('push', ({ page }) => {
    // The page state has been updated
    console.log('Now on component:', page.component);
});

// Programmatic navigation
router.go('/dashboard');

useForm()

The useForm composable provides a complete solution for form submissions, including state management, validation errors, and file uploads.

<script setup>
import { useForm } from 'fictif';

const form = useForm({
    name: 'John Doe',
    avatar: null,
});

const submit = () => {
    // This automatically handles FormData for file uploads
    form.post('/users');
};
</script>

<template>
  <form @submit.prevent="submit">
    <input type="text" v-model="form.data.name">
    <div v-if="form.errors.name">{{ form.errors.name }}</div>

    <input type="file" @input="form.data.avatar = $event.target.files[0]">

    <button type="submit" :disabled="form.processing">Save</button>
  </form>
</template>

RouterMap (For Client-Side Routing)

For SPAs or advanced routing needs, the RouterMap provides a powerful, Express.js-style API for defining your routes on the client.

// A custom resolver using RouterMap
import { RouterMap, response, redirect } from 'fictif';

const rm = new RouterMap();

// Apply a middleware to a group of routes
rm.middleware('auth', (req, next) => {
    if (!isLoggedIn()) {
        return redirect('/login').build();
    }
    return next(req);
});

rm.group(admin => {
    admin.get('/dashboard', () => response().component('admin.dashboard'));
    admin.get('/users', () => response().component('admin.users'));
}).prefix('/admin').applyMiddleware('auth');


// Use it in your router
const router = new Router({ resolve: rm });

Help

We have a Discord server in case you have any questions.

Contributing

Contributions are welcome! Please feel free to submit a pull request or open an issue.

License

Fictif is open-source software licensed under the MIT license.

Build Function-Calling Agents in Node.js with Agentic

Abderrahmene Merzoug — Fri, 11 Apr 2025 22:58:11 +0000

Building applications powered by Large Language Models (LLMs) is exciting, but making them truly useful often means giving them access to the real world – fetching live data, calling APIs, interacting with databases, or executing code. This is where "function calling" or "tool use" comes in, allowing the LLM to request actions from your application.

While powerful, implementing this interaction layer can quickly become complex. You need to:

Clearly define available tools for the LLM.
Format prompts correctly.
Parse the LLM's response to detect tool call requests.
Extract parameters accurately.
Execute the corresponding function in your code.
Handle potential errors during execution.
Format the tool's result back for the LLM.
Manage the conversation history across user messages, assistant responses, and tool interactions.
Handle streaming responses for a better user experience.

That's a lot of boilerplate! Wouldn't it be great if there was a lightweight, focused way to handle this in Node.js?

✨ Introducing @obayd/agentic

Meet @obayd/agentic – a simple yet powerful framework designed specifically to streamline the creation of function-calling LLM agents in Node.js. It focuses on providing the core building blocks you need without unnecessary complexity.

What can it do for you?

✅ Fluent Tool Definition: Define tools the LLM can use with a clean, chainable API (Tool.make().description().param()...).
📦 Toolpacks: Group related tools and let the LLM enable them on demand (Toolpack, enable_toolpack).
🌊 Streaming First: Built from the ground up for handling streaming LLM responses and tool events using async generators.
🔌 LLM Agnostic: Integrate with any LLM API that supports streaming responses via a simple callback function.
🗣️ Conversation Management: Automatically handles message history, system prompt generation (with tool docs!), tool call parsing, and result formatting.
⚙️ Dynamic Prompts: Define system prompt content dynamically based on runtime context.
🔒 Type-Safe: Includes TypeScript definitions for great DX, even in JS projects.
☀️ Zero-dependency.
🔍 Pure-javascript.

It aims to manage the interaction flow so you can focus on defining your tools and agent logic.

Let's Build an Agent! (Quick Start)

Let's create a simple weather agent that uses a custom tool.

1. Installation

npm install @obayd/agentic

2. The llmCallback (Connecting to Your LLM)

This is the core integration point. You provide an async function* that takes the formatted message history and calls your LLM's streaming API, yielding back text chunks.

// main.js
import { Conversation, Tool, fetchResponseToStream } from '@obayd/agentic';

// --- Your LLM Connection Logic ---
async function* llmCallback(messages, options) {
    // --- ⚠️ Replace with your actual API details! ---
    const YOUR_LLM_API_ENDPOINT = "YOUR_LLM_API_ENDPOINT"; // e.g., OpenAI, Anthropic, etc.
    const YOUR_API_KEY = "YOUR_API_KEY";
    const YOUR_MODEL_NAME = "YOUR_MODEL_NAME"; // e.g., gpt-4-turbo, claude-3-opus-20240229

    console.log("DEBUG: Sending messages to LLM:", JSON.stringify(messages, null, 2));

    try {
        const response = await fetch(YOUR_LLM_API_ENDPOINT, {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "Authorization": `Bearer ${YOUR_API_KEY}`,
                // Add any other required headers (e.g., 'anthropic-version': '2023-06-01')
            },
            body: JSON.stringify({
                model: YOUR_MODEL_NAME,
                messages: messages, // Pass the history formatted by agentic
                stream: true,       // MUST request streaming
                // Add other params (temperature, max_tokens, etc.)
                // Note: Adapt tool specification if your API requires a separate 'tools' array
                // alongside the system prompt instructions.
            }),
        });

        // Use the helper for standard Server-Sent Events (SSE)
        yield* fetchResponseToStream(response);

    } catch (error) {
        console.error("LLM Callback Error:", error);
        yield `[Error connecting to LLM: ${error.message}]`; // Surface errors
    }
}

3. Define Your Tool

Use the fluent Tool API.

// main.js (continued)

const getCurrentWeather = Tool.make("get_current_weather") // Unique name
    .description("Gets the current weather for a specified location.") // Crucial for LLM
    .param("location", "The city and state, e.g., San Francisco, CA", { required: true })
    .param("unit", "Temperature unit", { enum: ["celsius", "fahrenheit"] }) // Optional enum
    .action(async (params) => { // The function to execute
        console.log(`[TOOL ACTION] Getting weather for: ${params.location}`);
        // --- Your actual API call/logic here ---
        await new Promise(resolve => setTimeout(resolve, 75)); // Simulate delay
        const location = params.location.toLowerCase();
        const unit = params.unit || "celsius";
        let temp = location.includes("tokyo") ? 15 : 12;
        if (unit === "fahrenheit") temp = (temp * 9/5) + 32;

        // Return result for the LLM
        return JSON.stringify({ temperature: temp, unit: unit, condition: "Cloudy" });
    });

4. Setup the Conversation

Instantiate Conversation and define its content (prompt + tools).

// main.js (continued)

const conversation = new Conversation(llmCallback);

conversation.content([
    // System prompt parts
    "You are a helpful weather assistant.",
    "Use the available tools to answer user questions.",
    // Available tools
    getCurrentWeather,
]);

5. Run the Interaction Loop
Call conversation.send() and process the event stream.

// main.js (continued)

async function runAgent(userInput) {
    console.log(`\n👤 USER: ${userInput}`);
    console.log("\n🤖 ASSISTANT:");

    let fullResponse = "";
    try {
        const stream = conversation.send(userInput); // Get the async generator

        // Iterate through events as they arrive
        for await (const event of stream) {
            switch (event.type) {
                case 'assistant':
                    process.stdout.write(event.content); // Stream text output
                    fullResponse += event.content;
                    break;
                case 'tool.calling':
                    // LLM decided to call a tool!
                    process.stdout.write(`\n[⚙️ Calling Tool: ${event.name}(${JSON.stringify(event.params)})]`);
                    break;
                case 'tool':
                    // Tool finished! Result is available.
                    // The framework automatically sends this back to the LLM.
                    console.log(`\n[✅ Tool Result (${event.name})]: ${JSON.stringify(event.result)}`);
                    console.log("\n🤖 ASSISTANT (Processing result...):");
                    break;
                case 'error':
                    console.error(`\n[❌ CONVERSATION ERROR]: ${event.content}`);
                    break;
                // case 'tool.generating': // You can optionally handle raw input generation
                //     process.stdout.write('...');
                //     break;
            }
        }
        console.log('\n--- Turn End ---');
        return fullResponse;

    } catch (error) {
        console.error("\n[💥 Critical Agent Error]:", error);
    }
}

// --- Start the agent! ---
runAgent("What's the weather in Tokyo like today?");

// You can continue the conversation:
// setTimeout(() => runAgent("Thanks! How about in Fahrenheit?"), 2000); // Example follow-up

Example Flow & Output:
When you run this, you'll see something like:

👤 USER: What's the weather in Tokyo like today?

🤖 ASSISTANT:
[⚙️ Calling Tool: get_current_weather({"location":"Tokyo"})]


🤖 ASSISTANT (Processing result...):
The current weather in Tokyo is 15°C and Cloudy.
--- Turn End ---

Notice how the library handled:

Sending the prompt + tool definition.
Parsing the LLM's request to call get_current_weather.
Executing your action function.
Sending the { temperature: 15, ... } result back.
Getting the final natural language response from the LLM based on the tool result.
All while streaming the text output!

Why Choose @obayd/agentic?

Simplicity: Focuses on the core agent loop without excessive abstraction. Easy to learn and integrate.
Flexibility: Bring your own LLM. The llmCallback provides a simple but powerful integration point.
Streaming Native: Designed for responsive applications.
Clear Tool Definition: The fluent API makes defining tools intuitive.
Lightweight: No heavy dependencies.

Beyond the Basics

This was just a glimpse! Agentic also supports:

Toolpacks: Grouping tools (Toolpack.make().add(...)) and letting the LLM enable them via the built-in enable_toolpack tool. Keeps prompts clean!
Raw Tool Input: Tools that accept free-form text input using .raw().
Dynamic Content: Modifying the system prompt or available tools on-the-fly using async functions in .content().
Passing Arguments: Sending extra context to your tool actions via conversation.send(message, arg1, arg2).

Get Started!

Ready to give your LLM applications superpowers?

Install: npm install @obayd/agentic Check the Code: github.com/obaydmerz/agentic
Read the Docs: https://agentic.gitbook.io/agentic
Experiment!

Building powerful, interactive LLM agents just got a whole lot simpler. Give @obayd/agentic a try for your next Node.js project and let me know what you build!

Feedback and contributions are welcome! Feel free to open an issue or PR on GitHub.

Transforming GPT through API into a Fully Functional AI Assistant with LLMKit: A Step-by-Step Guide

Abderrahmene Merzoug — Fri, 19 Jul 2024 22:39:36 +0000

In recent years, large language models (LLMs) such as GPT-3 have shown incredible promise in generating human-like text, answering questions, and holding conversations. However, to transform an LLM into a fully functional AI assistant, we need more than just text generation capabilities. That's where LLMKit comes in. LLMKit is a powerful library designed to help developers convert their text-to-text LLMs into fully functional AI assistants, enabling them to perform specific tasks and handle real-world scenarios.

LLMKit simplifies the integration of LLMs into your applications by providing a modular plugin system, built-in retry mechanisms, and customizable conversation configurations. In this article, we will walk you through the process of creating a conversation with an external function call using LLMKit. By the end of this guide, you'll have a solid understanding of how to extend the capabilities of your LLM and build a responsive AI assistant.

Getting Started with LLMKit

To start using LLMKit, you'll need to install it from GitHub using npm. Open your terminal and run the following command:

npm i obaydmerz/llmkit

A step-by-step guide to create a conversation

Step 1: Importing modules and creating instances

import { Conversation, retry } from "llmkit";
import { External, ExternalFunction } from "llmkit/plugins/external";
// Import the OpenAI module here

also, instantiate the OpenAI client:

const gpt = new OpenAI_Instance_Or_Any_LLM();

Step 2: Create the conversation

Don't worry, we will explain the code below later:

let conv = Conversation.create(
    (m) => retry({}, (num) => gpt.chatCompletion(/*or any function*/(m, {
      debug: true
    }))),
    {
      plugins: [
        External.create([
          ExternalFunction.create("purchase", {
            description: "Orders something",
            parameters: {
              name: "string, The name of the product"
            },
            hook: async ({ name }) => {
              if (name.toLowerCase() == "pizza") {
                return "Ordered! Tell the user that the pizza is yummy";
              }
              return "Product Not Found";
            },
          }),
        ]),
      ],
    }
  );

Conversation is the main class in LLMKit that hold the conversation between three parts: system, user, agent

The Conversation.create() static function accepts two arguments:

The first argument, which is the function that's called to pass the string message to the GPT. ( notice the retry function which repeats the function if it fails )
The second argument is the options object.

Here we added External to plugins, External provides a way for the GPT/LLM to execute functions your code.

Step 3: Send a Message to the Conversation

(async () => {
     await conv.start();
     let res = await conv.send("I wanna purchase a burger");

     // You can access messages through conv.messages
     console.log(res); // I'm sorry, I couldn't find the burger you were looking for. How can I assist you further?
})();

After that all

If you still have any question, post it in the comments.
Join our discord server for further assistance!

🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀

PowerJS - Empower Your JavaScript with PowerShell Magic

Abderrahmene Merzoug — Sat, 09 Dec 2023 20:38:05 +0000

PowerJS is a powerful JavaScript library that enables you to seamlessly integrate and harness the magic of PowerShell directly from your scripts. Whether you need to automate administrative tasks, manage Windows processes, or interact with DLLs, PowerJS provides a user-friendly interface to supercharge your JavaScript applications.

Key Features

100% Pure javascript (no native files included): Enjoy more flexibility with a lower cost and a shorter setup process.
Dependency-less: PowerJS eliminates the need for additional dependencies, ensuring a lightweight and hassle-free integration with your projects.
Seamless PowerShell Integration: PowerJS enables you to execute PowerShell commands and scripts directly from your JavaScript or TypeScript code, making it easy to leverage the power of PowerShell within your application.
Extension Support: Extend PowerJS functionality with ease by adding custom extensions. These extensions can include additional PowerShell modules, functions, and capabilities to tailor PowerJS to your specific needs. ( You can make your own extensions and publish them )
DLL Integration: Import and interact with DLLs (Dynamic Link Libraries) in your PowerShell scripts. PowerJS simplifies the process of importing DLLs and provides a convenient interface for direct interaction.
Flexible Configuration: Configure PowerJS according to your requirements with options like specifying additional shell names, enabling elevated permissions (runas), and automatic startup of extensions.
Robust Error Handling: PowerJS includes robust error handling features, allowing you to capture and handle errors gracefully, ensuring your application remains stable even when executing complex PowerShell commands.
Asynchronous Execution: Execute PowerShell commands asynchronously, preventing your application from becoming unresponsive while waiting for script execution to complete.
Detailed Results: Access detailed results of PowerShell script executions, including standard output, standard error, and execution success status. PowerJS provides a convenient result object for easy data retrieval.
Comprehensive Documentation: PowerJS includes comprehensive TypeScript declaration files (.d.ts) and inline code comments, making it easy to understand and use the module in your projects.
Cross-Platform Compatibility: PowerJS is designed to work across different platforms, ensuring consistent PowerShell integration regardless of the operating system.
Elevated Permissions: Run PowerShell commands with elevated permissions when necessary, providing the ability to execute administrative tasks and interact with protected system resources. ( Coming Soon... )

Installation

Currently there are a way to install it directly from github.
( For recent features & recommended )

npm install obaydmerz/powerjs

Or from npm:
( For stable relases )

npm install @obayd/powerjs

Examples

// Print PowerShell Version
import { PowerJS } from "@obayd/powerjs";

const instance = new PowerJS(/* options */);

instance.exec("$PSVersionTable").then((result) => {
  // You may notice some slowdown, that's because of the instance init process.
  // After the instance is started, you can enjoy a blazing fast environnement!
  console.log("Currently on Powershell v" + result.PSVersion.Major + "!");
});

// Read the local user list
import { PowerJS } from "@obayd/powerjs";

const instance = new PowerJS();

instance.exec(",(Get-LocalUser)").then(function (result) {
  // Use the , to make arrays returnable, otherwise, it will return only the first item
  // Read https://stackoverflow.com/questions/29973212/pipe-complete-array-objects-instead-of-array-items-one-at-a-time

  for (const user of result) {
    console.log(user.Name);
  }
  process.exit();
});

// Import a DLL
import { PowerJS } from "@obayd/powerjs";

const instance = new PowerJS({
  dlls: {
    "user32.dll": {
      LockWorkStation: [], // Imports LockWorkStation as a function
      MessageBox: ["int", "IntPtr", "String", "String", "int"], // Also a function, Please note that the first item is the function type.
    },
  },
});

instance.dll.user32
  .MessageBox(0, "Lock your computer?", "Warning", 3)
  .then(async ({ result }) => {
    if (result == 6) {
      await instance.dll.user32.LockWorkStation();
    }
  });

// You should take a deep lock to see how this magic happens.
// This is a super easy out-of-the-box alternative to node-ffi.

// Make an extension
import { PowerJS, Extension } from "@obayd/powerjs";

class MyAwesomeExtension extends Extension {
  name = "myawesomeext";

  async getVersion() {
    const { result } = await this.instance.exec("$PSVersionTable");

    return result.PSVersion.Major;
  }
}

const instance = new PowerJS({
  extensions: [MyAwesomeExtension],
});

const myAwesomeExt = instance.getExtension(MyAwesomeExtension);
// OR: const myAwesomeExt = instance.getExtension("myawesomeext");

myAwesomeExt.getVersion().then((versionMajor) => {
  console.log("Huh ?! Powershell v" + versionMajor);
});

Easy, isn't it?

For more information and advanced usage, check out the PowerJS Wiki.

A laravel-like database management library for nodejs

Abderrahmene Merzoug — Sat, 09 Dec 2023 20:24:24 +0000

Have you heard about ORMs in nodejs history.

NodeORM is a lightweight and flexible Object-Relational Mapping (ORM) library for Node.js applications inspired by Laravel's one. It provides a seamless interface between JavaScript objects and relational databases, making it easier for developers to interact with their databases using familiar JavaScript syntax.

It simplifies and streamlines the process of working with relational databases, making database interactions more intuitive and developer-friendly. It empowers developers to focus on building robust applications without worrying about the complexities of database management. Whether you are working with MySQL, SQLite, or custom database solutions, NodeORM offers a seamless and consistent interface for your database needs.

Installation

It's heavily recommended to install from github to get latest changes.

npm install obaydmerz/nodeorm

However, for most stable builds you could use npm.

npm install @obayd/nodeorm

Keyfeatures

Database Agnostic: NodeORM supports multiple database drivers, including MySQL, SQLite, and custom raw function drivers, allowing users to work with their preferred databases.
Model Definition: Users can define their database models with properties such as table name, columns, and primary keys. This enables easy mapping of database tables to JavaScript classes.
Fluent Query Building: With a fluent method chaining syntax, NodeORM allows users to construct complex SQL queries in a natural and intuitive way, making it easy to create dynamic queries for database operations.
ModelItem Class: The ModelItem class represents individual items (rows) in the database table with CRUD methods. Users can interact with specific database records using this class.
Collection Class: The Collection class represents a group of ModelItems with grouping and filtering capabilities. It enables users to work with multiple records as a cohesive unit.
Error Handling: NodeORM defines custom error classes for specific error scenarios, such as EmptyDataError and UnmatchingStateError. This helps users handle errors more effectively and gracefully.
Dynamic Model Creation: Users can dynamically create models during runtime, eliminating the need to predefine them. This flexibility allows for more dynamic and adaptive database interactions.
Lazy Loading: NodeORM employs lazy loading optimizations during iteration, improving performance when dealing with large datasets.
Dependency-less: A plug and play library.
Fully compatible: The library automatically plugs with mysql, mysql2 and-or sqlite3.
Multi connections: You can connect to multiple databases at the same time seamlessly.
Unblocking structure: This library is based on async-await syntax.
And much other stuff...

// MySQL example
// Inserting a new row/item into a table named `test`.

import { Model, initialize } from "@obayd/nodeorm";

class Test extends Model {}

(async () => {
  await initialize("mysql://root@localhost:3306/mydb", Test);

  const myNewItem = Test.create();

  myNewItem.string_value = "We have a better tomorrow!";
  myNewItem.integer_value = 2024;

  await myNewItem.save();

  console.log(myNewItem.id); // Output: 1
})();

Changes in database:

// Reading the row that we just inserted.
// We used here an attribute *getter*

import { Model, initialize } from "../index.js";

class Test extends Model {
  static _ourPhrase() {
    // We used here an attribute *getter*
    // Note we used the following syntax _attributeName
    return this.string_value + " in the year of " + this.integer_value;
  }
}

(async () => {
  await initialize("mysql://root@localhost:3306/mydb", Test);

  const myLastItem = await Test.last();

  // We accessed an additional attribute.
  console.log(myLastItem.ourPhrase); // Output: We have a better tomorrow! in the year of 2024
})();

// Editing the row that we just inserted.

import { Model, initialize } from "@obayd/nodeorm";

class Test extends Model {}

(async () => {
  await initialize("mysql://root@localhost:3306/mydb", Test);

  const myLastItem = await Test.last();

  myLastItem.integer_value = 2025;

  await myLastItem.save();
})();

Changes in database:

// Deleting the row that we just inserted.
// Demonstrates how to use find() to *find* items

import { Model, initialize } from "@obayd/nodeorm";

class Test extends Model {}

(async () => {
  await initialize("mysql://root@localhost:3306/mydb", Test);

  //const myLastItem = await Test.last();

  // We used find() syntax instead of last() just to demonstrate how it works.
  //const myLastItem = await Test.where("id", 1);
  //const myLastItem = await Test.where("id", "=", 1);
  const myLastItem = await Test.find(1);

  await myLastItem.delete();
})();

Changes in database:

HeidiSQL is used to show database changes, consider supporting it.

Multi-support

NodeORM features accessing and managing other types of databases like sqlite.

// SQLite example
import { Model, initialize } from "@obayd/nodeorm";

class Test extends Model {}

(async () => {
  await initialize("C:/Users/Hello/Documents/mysqlite.db", Test);

  const my = await Test.last();
  console.log(my.string_value);
})();

Easy, isn't it?

For more information and advanced usage, check out the NodeORM Wiki

DEV Community: Abderrahmene Merzoug

I Got Tired of APIs, So I Built a New Vue Framework

The Pain Point: The "API Chasm"

Introducing Fictif: The Best of Both Worlds

What Makes Fictif Different?

I'd Love Your Feedback!

Fictif | An application framework for building modern, server-driven web apps with Vue 3

What is Fictif?

Features

Documentation

Installation

Usage

Inertia-like Usage

Core Concepts

useRouter() & Events

useForm()

RouterMap (For Client-Side Routing)

Help

Contributing

License

Build Function-Calling Agents in Node.js with Agentic

✨ Introducing @obayd/agentic

Let's Build an Agent! (Quick Start)

Why Choose @obayd/agentic?

Beyond the Basics

Get Started!

Transforming GPT through API into a Fully Functional AI Assistant with LLMKit: A Step-by-Step Guide

Getting Started with LLMKit

A step-by-step guide to create a conversation

Step 1: Importing modules and creating instances

Step 2: Create the conversation

Step 3: Send a Message to the Conversation

After that all

PowerJS - Empower Your JavaScript with PowerShell Magic

Key Features

Installation

Examples

Read more

A laravel-like database management library for nodejs

Installation

Keyfeatures

HeidiSQL is used to show database changes, consider supporting it.

Multi-support

Read more

I hope you have learnt something new and... bye 🌙