@3lineas/d1-orm 1.0.7 → 1.0.9

package/README.md

@@ -20,196 +20,92 @@ pnpm add @3lineas/d1-orm
 
 ## Initial Setup
 
-To get started, configure the database connection in your Worker. This is typically done in your application's entry point (e.g., `index.ts` or `server.ts`).
+By default, the ORM attempts to **auto-initialize** itself if your D1 binding is named `DB`.
 
-```typescript
-import { Database } from "@3lineas/d1-orm";
-
-export default {
-  async fetch(request, env, ctx) {
-    // Initialize the D1 connection (assuming it's named DB in wrangler.toml)
-    Database.setup(env.DB);
-
-    // ... your routing logic
-  },
-};
-```
-
-## Defining Models
-
-Define your models by extending the `Model` class. By default, the ORM assumes the table name is the lowercase plural form of the class name (e.g., `User` -> `users`).
+For zero-configuration setup in Cloudflare Workers or Next.js:
 
 ```typescript
-import { Model } from "@3lineas/d1-orm";
-
-export class User extends Model {
-  // Optional: Custom table name
-  // protected static table = 'my_users';
-
-  // Optional: Define attributes for typing (recommended)
-  declare id: number;
-  declare name: string;
-  declare email: string;
-  declare created_at: string;
-}
-```
-
-## CRUD Operations
-
-### Create
-
-```typescript
-const user = await User.create({
-  name: "John Doe",
-  email: "john@example.com",
-});
-```
-
-### Read
-
-```typescript
-// Get all records
+// No manual setup required if binding name is 'DB'!
 const users = await User.all();
-
-// Find by ID
-const user = await User.find(1);
-
-// Custom queries
-const activeUsers = await User.where("status", "=", "active")
-  .orderBy("created_at", "desc")
-  .get();
-
-// Get the first result
-const firstUser = await User.where("email", "john@example.com").first();
 ```
 
-### Update
+If you use a custom binding name or want manual control:
 
 ```typescript
-const user = await User.find(1);
-if (user) {
-  user.fill({ name: "Updated Name" });
-  await user.save();
-}
+import { Database } from "@3lineas/d1-orm";
 
-// Or update directly via query
-await User.where("status", "inactive").update({ status: "active" });
+export default {
+  async fetch(request, env, ctx) {
+    Database.setup(env.MY_CUSTOM_DB);
+    // ...
+  },
+};
 ```
 
-### Delete
-
-```typescript
-const user = await User.find(1);
-if (user) {
-  await user.delete();
-}
-
-// Or delete directly via query
-await User.where("status", "banned").delete();
-```
+## Directory Structure
 
-## Relationships
+When you run `init`, the ORM creates a unified structure in `src/database` (if `src` exists) or `database/`:
 
-Support for basic relationships to structure your data.
+- `database/models/`: Your Eloquent-style models.
+- `database/migrations/`: SQL migration files.
+- `database/seeders/`: Data seeders.
+- `database/config.ts`: Central configuration.
 
-### One to One (HasOne)
+### Configuration (`database/config.ts`)
 
 ```typescript
-// In User Model
-hasOneProfile() {
-    return this.hasOne(Profile);
-}
-
-// Usage
-const profile = await user.hasOneProfile().get();
+export default {
+  binding: "DB", // The name of your D1 binding
+};
 ```
 
-### One to Many (HasMany)
-
-```typescript
-// In User Model
-posts() {
-    return this.hasMany(Post);
-}
-
-// Usage
-const posts = await user.posts().get();
-```
+## Defining Models
 
-### Belongs To (BelongsTo)
+Define your models by extending the `Model` class. Models are typically placed in `database/models/`.
 
 ```typescript
-// In Post Model
-user() {
-    return this.belongsTo(User);
-}
+import { Model } from "@3lineas/d1-orm";
 
-// Usage
-const author = await post.user().get();
+export class User extends Model {
+  declare id: number;
+  declare name: string;
+}
 ```
 
 ## CLI & Migrations
 
-The ORM includes a CLI to simplify database management.
-
-### Automatic Configuration
+The ORM includes a modern, Astro-style CLI for database management.
 
-The `init` command will automatically configure the `orm` script in your `package.json`.
-
-To run the initial command (before the script is added):
+### Initialization
 
 ```bash
-npx d1-orm init
-```
-
-Once executed, the `orm` script will be added to your `package.json`:
-
-```json
-"scripts": {
-    "orm": "d1-orm"
-}
+pnpm d1-orm init
 ```
 
-From then on, you can use:
-
-```bash
-pnpm orm ...
-```
+This command is non-interactive and automatically detects your project structure.
 
 ### Available Commands
 
-#### Initialize Project
-
-An interactive command that sets up your project. It will ask where you want to keep your models and will automatically generate the directory structure, an example `User` model, its migration, and a seeder.
-
-#### Create a Model
-
-Generate a model file interactively. It allows you to optionally create a linked migration and seeder.
+#### Create Files
 
 ```bash
-pnpm orm make:model
-```
-
-#### Create a Migration
+# Create a model (and optionally migration/seeder)
+pnpm orm make:model User
 
-Generate a migration file interactively in `database/migrations`.
-
-```bash
-pnpm orm make:migration
+# Create a standalone migration
+pnpm orm make:migration create_posts_table
 ```
 
 #### Run Migrations
 
-Run pending migrations.
-
 ```bash
-# Local (default)
+# Local
 pnpm orm migrate
 
-# Remote (Production)
+# Remote
 pnpm orm migrate --remote
 
-# Run migrations and then seed
+# Migrate and then seed
 pnpm orm migrate --seed
 ```
 
@@ -230,12 +126,9 @@ Run seeders defined in `database/seeders`.
 
 ```bash
 pnpm orm db:seed
-
-# Remote
-pnpm orm db:seed --remote
 ```
 
-> **Note:** Local migrations require `wrangler` to be configured and running in your environment.
+> **Note:** The CLI automatically detects your `wrangler.jsonc`, `wrangler.json` or `wrangler.toml` to find your D1 binding.
 
 ---
 

package/dist/chunk-N3G6NOJP.js

@@ -0,0 +1,127 @@
+// src/core/connection.ts
+var Connection = class {
+  /**
+   * The underlying D1Database instance.
+   */
+  db;
+  /**
+   * Create a new Connection instance.
+   *
+   * @param database - The D1Database instance.
+   */
+  constructor(database) {
+    this.db = database;
+  }
+  /**
+   * Execute a SELECT statement.
+   *
+   * @param query - The SQL query string.
+   * @param bindings - The parameter bindings.
+   * @returns A promise that resolves to an array of results.
+   */
+  async select(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.all();
+    return result.results || [];
+  }
+  /**
+   * Execute an INSERT statement.
+   *
+   * @param query - The SQL query string.
+   * @param bindings - The parameter bindings.
+   * @returns A promise that resolves to true on success.
+   */
+  async insert(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+  /**
+   * Execute an UPDATE statement.
+   *
+   * @param query - The SQL query string.
+   * @param bindings - The parameter bindings.
+   * @returns A promise that resolves to true on success.
+   */
+  async update(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+  /**
+   * Execute a DELETE statement.
+   *
+   * @param query - The SQL query string.
+   * @param bindings - The parameter bindings.
+   * @returns A promise that resolves to true on success.
+   */
+  async delete(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+  /**
+   * Execute an arbitrary SQL statement.
+   *
+   * @param query - The SQL query string.
+   * @param bindings - The parameter bindings.
+   * @returns A promise that resolves to true on success.
+   */
+  async statement(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+};
+
+// src/core/database.ts
+var Database = class _Database {
+  /**
+   * Symbol for global singleton access.
+   */
+  static INSTANCE_KEY = /* @__PURE__ */ Symbol.for("d1-orm-instance");
+  /**
+   * The active database connection.
+   */
+  connection;
+  /**
+   * Private constructor to enforce singleton pattern.
+   *
+   * @param d1 - The D1Database instance from Cloudflare.
+   */
+  constructor(d1) {
+    this.connection = new Connection(d1);
+  }
+  /**
+   * Setup the database connection.
+   *
+   * @param d1 - The D1Database instance from Cloudflare environment (env.DB).
+   */
+  static setup(d1) {
+    globalThis[_Database.INSTANCE_KEY] = new _Database(d1);
+  }
+  /**
+   * Get the singleton Database instance.
+   *
+   * @throws Error if setup() has not been called and auto-init fails.
+   * @returns The Database instance.
+   */
+  static getInstance() {
+    const instance = globalThis[_Database.INSTANCE_KEY];
+    if (!instance) {
+      if (globalThis["DB"] && typeof globalThis["DB"].prepare === "function") {
+        _Database.setup(globalThis["DB"]);
+        return globalThis[_Database.INSTANCE_KEY];
+      }
+      throw new Error(
+        "Database not initialized. Call Database.setup(env.DB) first or ensure your D1 binding is named 'DB'."
+      );
+    }
+    return instance;
+  }
+};
+
+export {
+  Connection,
+  Database
+};