@firekid/forgedb 1.0.0

package/README.md

@@ -0,0 +1,191 @@
+# @firekid/forgedb
+
+[![npm version](https://img.shields.io/npm/v/@firekid/forgedb?style=flat-square&color=CB3837)](https://npmjs.com/package/@firekid/forgedb)
+[![License: MIT](https://img.shields.io/badge/License-MIT-22C55E?style=flat-square)](LICENSE)
+
+Official JavaScript/TypeScript client for [ForgeDB](https://forgedb.name.ng). Powered by [`@firekid/hurl`](https://npmjs.com/package/@firekid/hurl) — zero extra dependencies.
+
+---
+
+## Install
+
+```bash
+npm install @firekid/forgedb
+pnpm add @firekid/forgedb
+yarn add @firekid/forgedb
+```
+
+---
+
+## Quick Start
+
+```ts
+import { createClient } from '@firekid/forgedb'
+
+const db = createClient({
+  projectId: 'your-project-id',
+  apiKey: 'sk_live_...',
+})
+```
+
+Get your `projectId` and `apiKey` from the [ForgeDB dashboard](https://forgedb.name.ng/app/keys).
+
+---
+
+## Selecting Rows
+
+```ts
+const { rows, total, totalPages } = await db.from('users').select()
+```
+
+### Filter
+
+```ts
+// Equality shorthand
+const { rows } = await db.from('users').where('active', true).select()
+
+// With operator — supports: = | != | > | < | >= | <= | like | in
+const { rows } = await db.from('users').where('age', '>', 18).select()
+
+// Chain multiple filters (AND)
+const { rows } = await db.from('users')
+  .where('active', true)
+  .where('age', '>=', 18)
+  .select()
+```
+
+### Pagination
+
+```ts
+const { rows } = await db.from('users').page(2).limit(20).select()
+```
+
+### Search
+
+```ts
+const { rows } = await db.from('users').search('john').select()
+```
+
+### Sort
+
+```ts
+const { rows } = await db.from('users').orderBy('createdAt', 'desc').select()
+```
+
+### Get by ID
+
+```ts
+const user = await db.from('users').selectById(1)
+```
+
+---
+
+## Mutating Rows
+
+### Insert
+
+```ts
+const user = await db.from('users').insert({
+  name: 'John Doe',
+  email: 'john@example.com',
+})
+```
+
+### Update
+
+```ts
+const user = await db.from('users').update(1, { name: 'Jane Doe' })
+```
+
+### Delete
+
+```ts
+await db.from('users').delete(1)
+```
+
+### Bulk Delete
+
+```ts
+await db.from('users').bulkDelete([1, 2, 3])
+```
+
+---
+
+## Raw SQL
+
+```ts
+// Single statement
+const result = await db.sql('SELECT * FROM users WHERE age > 18')
+console.log(result.rows)
+
+// Multiple statements
+const result = await db.sql(`
+  INSERT INTO logs (event) VALUES ('signup');
+  SELECT COUNT(*) as total FROM users;
+`)
+console.log(result.statements) // 2
+console.log(result.message)    // "2 statements executed · 1 row affected"
+```
+
+---
+
+## TypeScript
+
+```ts
+interface User {
+  id: number
+  name: string
+  email: string
+  age: number
+  active: boolean
+  createdAt: string
+  updatedAt: string
+}
+
+const { rows } = await db.from<User>('users').select()
+// rows → User[]
+
+const user = await db.from<User>('users').selectById(1)
+// user → User
+```
+
+---
+
+## Environments
+
+The client automatically detects the environment from your API key:
+
+| Key prefix        | Environment |
+|-------------------|-------------|
+| `sk_live_` / `fk_live_` | `prod` |
+| `sk_test_` / `fk_test_` | `test` |
+
+```ts
+console.log(db.environment) // 'prod' or 'test'
+```
+
+---
+
+## Error Handling
+
+```ts
+import { createClient, ForgeDBError } from '@firekid/forgedb'
+
+try {
+  await db.from('users').insert({ name: 'John' })
+} catch (err) {
+  if (err instanceof ForgeDBError) {
+    console.log(err.message) // human-readable message
+    console.log(err.code)    // e.g. 'VALIDATION_ERROR'
+    console.log(err.status)  // HTTP status code
+    console.log(err.line)    // SQL line (for query errors)
+    console.log(err.token)   // offending token (for query errors)
+  }
+}
+```
+
+---
+
+## License
+
+MIT © [Firekid](https://github.com/Firekid-is-him)

package/dist/index.d.mts

@@ -0,0 +1,131 @@
+import hurl from '@firekid/hurl';
+
+interface ForgeDBConfig {
+    /** Your ForgeDB project ID */
+    projectId: string;
+    /** Your API key — sk_live_... / fk_live_... / sk_test_... / fk_test_... */
+    apiKey: string;
+    /** Override the API base URL (optional) */
+    baseUrl?: string;
+}
+interface Row {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface SelectResult<T> {
+    rows: T[];
+    total: number;
+    totalPages: number;
+}
+interface SqlResult {
+    rows: Record<string, unknown>[];
+    total: number;
+    rowsAffected: number;
+    executionTime: number;
+    message?: string;
+    statements?: number;
+}
+type FilterOperator = '=' | '!=' | '>' | '<' | '>=' | '<=' | 'like' | 'in';
+declare class ForgeDBError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly line?: number;
+    readonly token?: string;
+    constructor(message: string, code: string, status: number, meta?: {
+        line?: number;
+        token?: string;
+    });
+}
+declare class QueryBuilder<T extends Row = Row> {
+    private readonly http;
+    private readonly projectId;
+    private readonly env;
+    private readonly table;
+    private _filters;
+    private _page?;
+    private _limit?;
+    private _search?;
+    private _sort?;
+    private _order?;
+    constructor(http: ReturnType<typeof hurl.create>, projectId: string, env: string, table: string);
+    /** Filter rows — chain multiple for AND. Shorthand: .where('active', true) or .where('age', '>', 18) */
+    where(column: string, operatorOrValue: FilterOperator | unknown, value?: unknown): this;
+    page(n: number): this;
+    limit(n: number): this;
+    search(query: string): this;
+    orderBy(column: string, direction?: 'asc' | 'desc'): this;
+    private get basePath();
+    private buildQuery;
+    /** Fetch all rows matching the current filters */
+    select(): Promise<SelectResult<T>>;
+    /** Fetch a single row by ID */
+    selectById(id: number | string): Promise<T>;
+    /** Insert a new row */
+    insert(data: Partial<Omit<T, 'id' | 'createdAt' | 'updatedAt'>>): Promise<T>;
+    /** Update a row by ID */
+    update(id: number | string, data: Partial<Omit<T, 'id' | 'createdAt' | 'updatedAt'>>): Promise<T>;
+    /** Delete a row by ID */
+    delete(id: number | string): Promise<{
+        success: boolean;
+    }>;
+    /** Delete multiple rows by IDs */
+    bulkDelete(ids: number[]): Promise<{
+        success: boolean;
+        deleted: number;
+    }>;
+}
+declare class ForgeDBClient {
+    private readonly http;
+    private readonly _projectId;
+    private readonly _env;
+    constructor(config: ForgeDBConfig);
+    /**
+     * Select a table to query.
+     * @example
+     * const { rows } = await db.from('users').select()
+     * const user = await db.from<User>('users').where('active', true).limit(10).select()
+     */
+    from<T extends Row = Row>(table: string): QueryBuilder<T>;
+    /**
+     * Run a raw SQL query. Supports multiple statements separated by ;
+     * @example
+     * const result = await db.sql('SELECT * FROM users WHERE age > 18')
+     */
+    sql(query: string): Promise<SqlResult>;
+    get environment(): 'prod' | 'test';
+    get projectId(): string;
+}
+/**
+ * Create a ForgeDB client.
+ *
+ * @example
+ * import { createClient } from '@firekid/forgedb'
+ *
+ * const db = createClient({
+ *   projectId: 'abc123',
+ *   apiKey: 'sk_live_...',
+ * })
+ *
+ * // Select
+ * const { rows } = await db.from('users').select()
+ *
+ * // Filter + paginate
+ * const { rows } = await db.from('users').where('age', '>', 18).page(1).limit(20).select()
+ *
+ * // Insert
+ * const user = await db.from('users').insert({ name: 'John', email: 'john@example.com' })
+ *
+ * // Update
+ * await db.from('users').update(1, { name: 'Jane' })
+ *
+ * // Delete
+ * await db.from('users').delete(1)
+ *
+ * // Raw SQL
+ * const result = await db.sql('SELECT COUNT(*) as total FROM users')
+ */
+declare function createClient(config: ForgeDBConfig): ForgeDBClient;
+
+export { type FilterOperator, ForgeDBClient, type ForgeDBConfig, ForgeDBError, QueryBuilder, type Row, type SelectResult, type SqlResult, createClient, createClient as default };

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+import hurl from '@firekid/hurl';
+
+interface ForgeDBConfig {
+    /** Your ForgeDB project ID */
+    projectId: string;
+    /** Your API key — sk_live_... / fk_live_... / sk_test_... / fk_test_... */
+    apiKey: string;
+    /** Override the API base URL (optional) */
+    baseUrl?: string;
+}
+interface Row {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface SelectResult<T> {
+    rows: T[];
+    total: number;
+    totalPages: number;
+}
+interface SqlResult {
+    rows: Record<string, unknown>[];
+    total: number;
+    rowsAffected: number;
+    executionTime: number;
+    message?: string;
+    statements?: number;
+}
+type FilterOperator = '=' | '!=' | '>' | '<' | '>=' | '<=' | 'like' | 'in';
+declare class ForgeDBError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly line?: number;
+    readonly token?: string;
+    constructor(message: string, code: string, status: number, meta?: {
+        line?: number;
+        token?: string;
+    });
+}
+declare class QueryBuilder<T extends Row = Row> {
+    private readonly http;
+    private readonly projectId;
+    private readonly env;
+    private readonly table;
+    private _filters;
+    private _page?;
+    private _limit?;
+    private _search?;
+    private _sort?;
+    private _order?;
+    constructor(http: ReturnType<typeof hurl.create>, projectId: string, env: string, table: string);
+    /** Filter rows — chain multiple for AND. Shorthand: .where('active', true) or .where('age', '>', 18) */
+    where(column: string, operatorOrValue: FilterOperator | unknown, value?: unknown): this;
+    page(n: number): this;
+    limit(n: number): this;
+    search(query: string): this;
+    orderBy(column: string, direction?: 'asc' | 'desc'): this;
+    private get basePath();
+    private buildQuery;
+    /** Fetch all rows matching the current filters */
+    select(): Promise<SelectResult<T>>;
+    /** Fetch a single row by ID */
+    selectById(id: number | string): Promise<T>;
+    /** Insert a new row */
+    insert(data: Partial<Omit<T, 'id' | 'createdAt' | 'updatedAt'>>): Promise<T>;
+    /** Update a row by ID */
+    update(id: number | string, data: Partial<Omit<T, 'id' | 'createdAt' | 'updatedAt'>>): Promise<T>;
+    /** Delete a row by ID */
+    delete(id: number | string): Promise<{
+        success: boolean;
+    }>;
+    /** Delete multiple rows by IDs */
+    bulkDelete(ids: number[]): Promise<{
+        success: boolean;
+        deleted: number;
+    }>;
+}
+declare class ForgeDBClient {
+    private readonly http;
+    private readonly _projectId;
+    private readonly _env;
+    constructor(config: ForgeDBConfig);
+    /**
+     * Select a table to query.
+     * @example
+     * const { rows } = await db.from('users').select()
+     * const user = await db.from<User>('users').where('active', true).limit(10).select()
+     */
+    from<T extends Row = Row>(table: string): QueryBuilder<T>;
+    /**
+     * Run a raw SQL query. Supports multiple statements separated by ;
+     * @example
+     * const result = await db.sql('SELECT * FROM users WHERE age > 18')
+     */
+    sql(query: string): Promise<SqlResult>;
+    get environment(): 'prod' | 'test';
+    get projectId(): string;
+}
+/**
+ * Create a ForgeDB client.
+ *
+ * @example
+ * import { createClient } from '@firekid/forgedb'
+ *
+ * const db = createClient({
+ *   projectId: 'abc123',
+ *   apiKey: 'sk_live_...',
+ * })
+ *
+ * // Select
+ * const { rows } = await db.from('users').select()
+ *
+ * // Filter + paginate
+ * const { rows } = await db.from('users').where('age', '>', 18).page(1).limit(20).select()
+ *
+ * // Insert
+ * const user = await db.from('users').insert({ name: 'John', email: 'john@example.com' })
+ *
+ * // Update
+ * await db.from('users').update(1, { name: 'Jane' })
+ *
+ * // Delete
+ * await db.from('users').delete(1)
+ *
+ * // Raw SQL
+ * const result = await db.sql('SELECT COUNT(*) as total FROM users')
+ */
+declare function createClient(config: ForgeDBConfig): ForgeDBClient;
+
+export { type FilterOperator, ForgeDBClient, type ForgeDBConfig, ForgeDBError, QueryBuilder, type Row, type SelectResult, type SqlResult, createClient, createClient as default };

package/dist/index.js

@@ -0,0 +1,226 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ForgeDBClient: () => ForgeDBClient,
+  ForgeDBError: () => ForgeDBError,
+  QueryBuilder: () => QueryBuilder,
+  createClient: () => createClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_hurl = __toESM(require("@firekid/hurl"));
+var DEFAULT_BASE_URL = "https://api.forgedb.name.ng";
+var ForgeDBError = class extends Error {
+  constructor(message, code, status, meta) {
+    super(message);
+    this.name = "ForgeDBError";
+    this.code = code;
+    this.status = status;
+    this.line = meta?.line;
+    this.token = meta?.token;
+  }
+};
+function wrapError(err) {
+  if (err instanceof import_hurl.HurlError) {
+    const body = err.data;
+    throw new ForgeDBError(
+      body?.error ?? err.message,
+      body?.code ?? err.type,
+      err.status ?? 500,
+      { line: body?.line, token: body?.token }
+    );
+  }
+  throw err;
+}
+var QueryBuilder = class {
+  constructor(http, projectId, env, table) {
+    this.http = http;
+    this.projectId = projectId;
+    this.env = env;
+    this.table = table;
+    this._filters = [];
+  }
+  /** Filter rows — chain multiple for AND. Shorthand: .where('active', true) or .where('age', '>', 18) */
+  where(column, operatorOrValue, value) {
+    if (value === void 0) {
+      this._filters.push({ column, op: "=", value: operatorOrValue });
+    } else {
+      this._filters.push({ column, op: operatorOrValue, value });
+    }
+    return this;
+  }
+  page(n) {
+    this._page = n;
+    return this;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  search(query) {
+    this._search = query;
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    this._sort = column;
+    this._order = direction;
+    return this;
+  }
+  get basePath() {
+    return `/v1/${this.projectId}/${this.env}/${this.table}`;
+  }
+  buildQuery() {
+    const q = {};
+    if (this._page) q["page"] = this._page;
+    if (this._limit) q["limit"] = this._limit;
+    if (this._search) q["search"] = this._search;
+    if (this._sort) q["sort"] = this._sort;
+    if (this._order) q["order"] = this._order;
+    this._filters.forEach((f, i) => {
+      q[`filter[${i}][col]`] = f.column;
+      q[`filter[${i}][op]`] = f.op;
+      q[`filter[${i}][val]`] = String(f.value);
+    });
+    return q;
+  }
+  /** Fetch all rows matching the current filters */
+  async select() {
+    try {
+      const res = await this.http.get(this.basePath, { query: this.buildQuery() });
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Fetch a single row by ID */
+  async selectById(id) {
+    try {
+      const res = await this.http.get(`${this.basePath}/${id}`);
+      return res.data.row;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Insert a new row */
+  async insert(data) {
+    try {
+      const res = await this.http.post(this.basePath, data);
+      return res.data.row;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Update a row by ID */
+  async update(id, data) {
+    try {
+      const res = await this.http.put(`${this.basePath}/${id}`, data);
+      return res.data.row;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Delete a row by ID */
+  async delete(id) {
+    try {
+      const res = await this.http.delete(`${this.basePath}/${id}`);
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Delete multiple rows by IDs */
+  async bulkDelete(ids) {
+    try {
+      const res = await this.http.delete(
+        `${this.basePath}/bulk-delete`,
+        { body: { ids } }
+      );
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+};
+var ForgeDBClient = class {
+  constructor(config) {
+    this._projectId = config.projectId;
+    this._env = config.apiKey.includes("_test_") ? "test" : "prod";
+    this.http = import_hurl.default.create({
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      auth: { type: "bearer", token: config.apiKey },
+      timeout: 15e3,
+      retry: { count: 2, backoff: "exponential", on: [500, 502, 503, 504] }
+    });
+  }
+  /**
+   * Select a table to query.
+   * @example
+   * const { rows } = await db.from('users').select()
+   * const user = await db.from<User>('users').where('active', true).limit(10).select()
+   */
+  from(table) {
+    return new QueryBuilder(this.http, this._projectId, this._env, table);
+  }
+  /**
+   * Run a raw SQL query. Supports multiple statements separated by ;
+   * @example
+   * const result = await db.sql('SELECT * FROM users WHERE age > 18')
+   */
+  async sql(query) {
+    try {
+      const res = await this.http.post(
+        `/v1/${this._projectId}/${this._env}/query`,
+        { sql: query }
+      );
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  get environment() {
+    return this._env;
+  }
+  get projectId() {
+    return this._projectId;
+  }
+};
+function createClient(config) {
+  return new ForgeDBClient(config);
+}
+var index_default = createClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForgeDBClient,
+  ForgeDBError,
+  QueryBuilder,
+  createClient
+});

package/dist/index.mjs

@@ -0,0 +1,188 @@
+// src/index.ts
+import hurl, { HurlError } from "@firekid/hurl";
+var DEFAULT_BASE_URL = "https://api.forgedb.name.ng";
+var ForgeDBError = class extends Error {
+  constructor(message, code, status, meta) {
+    super(message);
+    this.name = "ForgeDBError";
+    this.code = code;
+    this.status = status;
+    this.line = meta?.line;
+    this.token = meta?.token;
+  }
+};
+function wrapError(err) {
+  if (err instanceof HurlError) {
+    const body = err.data;
+    throw new ForgeDBError(
+      body?.error ?? err.message,
+      body?.code ?? err.type,
+      err.status ?? 500,
+      { line: body?.line, token: body?.token }
+    );
+  }
+  throw err;
+}
+var QueryBuilder = class {
+  constructor(http, projectId, env, table) {
+    this.http = http;
+    this.projectId = projectId;
+    this.env = env;
+    this.table = table;
+    this._filters = [];
+  }
+  /** Filter rows — chain multiple for AND. Shorthand: .where('active', true) or .where('age', '>', 18) */
+  where(column, operatorOrValue, value) {
+    if (value === void 0) {
+      this._filters.push({ column, op: "=", value: operatorOrValue });
+    } else {
+      this._filters.push({ column, op: operatorOrValue, value });
+    }
+    return this;
+  }
+  page(n) {
+    this._page = n;
+    return this;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  search(query) {
+    this._search = query;
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    this._sort = column;
+    this._order = direction;
+    return this;
+  }
+  get basePath() {
+    return `/v1/${this.projectId}/${this.env}/${this.table}`;
+  }
+  buildQuery() {
+    const q = {};
+    if (this._page) q["page"] = this._page;
+    if (this._limit) q["limit"] = this._limit;
+    if (this._search) q["search"] = this._search;
+    if (this._sort) q["sort"] = this._sort;
+    if (this._order) q["order"] = this._order;
+    this._filters.forEach((f, i) => {
+      q[`filter[${i}][col]`] = f.column;
+      q[`filter[${i}][op]`] = f.op;
+      q[`filter[${i}][val]`] = String(f.value);
+    });
+    return q;
+  }
+  /** Fetch all rows matching the current filters */
+  async select() {
+    try {
+      const res = await this.http.get(this.basePath, { query: this.buildQuery() });
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Fetch a single row by ID */
+  async selectById(id) {
+    try {
+      const res = await this.http.get(`${this.basePath}/${id}`);
+      return res.data.row;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Insert a new row */
+  async insert(data) {
+    try {
+      const res = await this.http.post(this.basePath, data);
+      return res.data.row;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Update a row by ID */
+  async update(id, data) {
+    try {
+      const res = await this.http.put(`${this.basePath}/${id}`, data);
+      return res.data.row;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Delete a row by ID */
+  async delete(id) {
+    try {
+      const res = await this.http.delete(`${this.basePath}/${id}`);
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  /** Delete multiple rows by IDs */
+  async bulkDelete(ids) {
+    try {
+      const res = await this.http.delete(
+        `${this.basePath}/bulk-delete`,
+        { body: { ids } }
+      );
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+};
+var ForgeDBClient = class {
+  constructor(config) {
+    this._projectId = config.projectId;
+    this._env = config.apiKey.includes("_test_") ? "test" : "prod";
+    this.http = hurl.create({
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      auth: { type: "bearer", token: config.apiKey },
+      timeout: 15e3,
+      retry: { count: 2, backoff: "exponential", on: [500, 502, 503, 504] }
+    });
+  }
+  /**
+   * Select a table to query.
+   * @example
+   * const { rows } = await db.from('users').select()
+   * const user = await db.from<User>('users').where('active', true).limit(10).select()
+   */
+  from(table) {
+    return new QueryBuilder(this.http, this._projectId, this._env, table);
+  }
+  /**
+   * Run a raw SQL query. Supports multiple statements separated by ;
+   * @example
+   * const result = await db.sql('SELECT * FROM users WHERE age > 18')
+   */
+  async sql(query) {
+    try {
+      const res = await this.http.post(
+        `/v1/${this._projectId}/${this._env}/query`,
+        { sql: query }
+      );
+      return res.data;
+    } catch (e) {
+      wrapError(e);
+    }
+  }
+  get environment() {
+    return this._env;
+  }
+  get projectId() {
+    return this._projectId;
+  }
+};
+function createClient(config) {
+  return new ForgeDBClient(config);
+}
+var index_default = createClient;
+export {
+  ForgeDBClient,
+  ForgeDBError,
+  QueryBuilder,
+  createClient,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@firekid/forgedb",
+  "version": "1.0.0",
+  "description": "Official JavaScript/TypeScript client for ForgeDB",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean"
+  },
+  "keywords": ["forgedb", "database", "firekid", "sdk", "client"],
+  "author": "Firekid",
+  "license": "MIT",
+  "dependencies": {
+    "@firekid/hurl": "latest"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}