@promakeai/orm 1.0.0

package/README.md

@@ -0,0 +1,154 @@
+# @promakeai/orm
+
+Core ORM package with schema DSL, query builder, and multi-language support.
+
+## Installation
+
+```bash
+npm install @promakeai/orm
+```
+
+## Schema Definition
+
+```typescript
+import { defineSchema, f } from '@promakeai/orm';
+
+const schema = defineSchema({
+  name: 'myapp',
+  languages: ['en', 'tr'],
+  defaultLanguage: 'en',
+  tables: {
+    users: {
+      id: f.id(),
+      email: f.string().required().unique(),
+      name: f.string().required(),
+      role: f.string().default('user').enum(['user', 'admin']),
+      createdAt: f.timestamp().default('now'),
+    },
+    products: {
+      id: f.id(),
+      sku: f.string().required().unique(),
+      price: f.decimal().required(),
+      stock: f.int().default(0),
+      name: f.string().translatable(),        // Multi-language
+      description: f.text().translatable(),   // Multi-language
+      categoryId: f.int().ref('categories'),  // Reference
+    },
+    categories: {
+      id: f.id(),
+      slug: f.string().required().unique(),
+      name: f.string().translatable(),
+    },
+  },
+});
+```
+
+## Field Types
+
+| Type | Description |
+|------|-------------|
+| `f.id()` | Auto-increment primary key |
+| `f.string()` | Short text |
+| `f.text()` | Long text |
+| `f.int()` | Integer |
+| `f.decimal()` | Decimal number |
+| `f.bool()` | Boolean |
+| `f.timestamp()` | ISO datetime |
+| `f.json()` | JSON data |
+
+## Field Modifiers
+
+```typescript
+f.string()
+  .required()              // NOT NULL
+  .unique()                // UNIQUE constraint
+  .default('value')        // Default value
+  .enum(['a', 'b', 'c'])   // Allowed values
+  .min(1).max(100)         // Value bounds
+  .translatable()          // Multi-language field
+  .ref('table')            // Reference to another table
+  .ref({ table: 'users', field: 'id', onDelete: 'CASCADE' })
+```
+
+## Query Builder (MongoDB-style)
+
+```typescript
+import { buildWhere } from '@promakeai/orm';
+
+// Simple equality
+buildWhere({ status: 'active' });
+// WHERE status = 'active'
+
+// Comparison operators
+buildWhere({ price: { $gt: 100 } });           // > 100
+buildWhere({ price: { $gte: 100 } });          // >= 100
+buildWhere({ price: { $lt: 100 } });           // < 100
+buildWhere({ price: { $lte: 100 } });          // <= 100
+buildWhere({ status: { $ne: 'deleted' } });    // != 'deleted'
+
+// Array operators
+buildWhere({ id: { $in: [1, 2, 3] } });        // IN (1, 2, 3)
+buildWhere({ id: { $nin: [1, 2, 3] } });       // NOT IN (1, 2, 3)
+
+// String matching
+buildWhere({ name: { $like: '%john%' } });     // LIKE '%john%'
+buildWhere({ name: { $notLike: '%test%' } });  // NOT LIKE '%test%'
+
+// Range and null
+buildWhere({ price: { $between: [10, 100] } }); // BETWEEN 10 AND 100
+buildWhere({ deletedAt: { $isNull: true } });   // IS NULL
+buildWhere({ email: { $isNull: false } });      // IS NOT NULL
+
+// Logical operators
+buildWhere({ $or: [{ active: true }, { role: 'admin' }] });
+buildWhere({ $and: [{ price: { $gt: 50 } }, { stock: { $gt: 0 } }] });
+buildWhere({ $nor: [{ banned: true }, { suspended: true }] });
+```
+
+## Multi-Language Support
+
+Schema fields marked with `.translatable()` are stored in separate translation tables:
+
+```typescript
+// Schema
+products: {
+  id: f.id(),
+  price: f.decimal(),
+  name: f.string().translatable(),      // Stored in products_translations
+  description: f.text().translatable(), // Stored in products_translations
+}
+
+// Creates tables:
+// - products (id, price)
+// - products_translations (id, product_id, lang, name, description)
+```
+
+Query with language:
+
+```typescript
+const products = await dm.query('products', {
+  lang: 'tr',
+  fallbackLang: 'en',  // Falls back if translation missing
+});
+```
+
+## Types
+
+```typescript
+import type {
+  Schema,
+  TableDefinition,
+  FieldDefinition,
+  QueryOptions,
+  WhereClause,
+} from '@promakeai/orm';
+```
+
+## Related Packages
+
+- [@promakeai/dbcli](../dbcli) - CLI tool
+- [@promakeai/dbreact](../dbreact) - React integration
+
+## License
+
+MIT

package/dist/ORM.d.ts

@@ -0,0 +1,190 @@
+/**
+ * ORM Class - Main Entry Point
+ *
+ * Database-agnostic ORM that works with any adapter implementing IDataAdapter.
+ *
+ * @example
+ * ```typescript
+ * import { ORM } from '@promakeai/orm';
+ * import { SqliteAdapter } from '@promakeai/dbcli';
+ *
+ * const adapter = new SqliteAdapter('./database.db');
+ * const db = new ORM(adapter);
+ *
+ * // List with filters and populate
+ * const posts = await db.list('posts', {
+ *   where: { published: true },
+ *   populate: ['userId', 'categoryIds'],
+ *   orderBy: [{ field: 'created_at', direction: 'DESC' }],
+ *   limit: 10,
+ * });
+ *
+ * // Create
+ * const post = await db.create('posts', { title: 'Hello', published: true });
+ *
+ * // Transaction
+ * await db.transaction(async (tx) => {
+ *   await tx.create('posts', { title: 'Post 1' });
+ *   await tx.create('posts', { title: 'Post 2' });
+ * });
+ * ```
+ */
+import type { IDataAdapter } from "./adapters/IDataAdapter";
+import type { QueryOptions, PaginatedResult, SchemaDefinition, ORMConfig } from "./types";
+/**
+ * Main ORM class - Completely adapter agnostic
+ */
+export declare class ORM {
+    private adapter;
+    private schema?;
+    private defaultLang;
+    private fallbackLang?;
+    /**
+     * Create ORM instance with any adapter
+     *
+     * @param adapter - Any object implementing IDataAdapter interface
+     * @param config - Optional configuration
+     */
+    constructor(adapter: IDataAdapter, config?: ORMConfig);
+    /**
+     * List records from table
+     *
+     * @example
+     * ```typescript
+     * // Simple list
+     * const products = await db.list('products');
+     *
+     * // With populate
+     * const products = await db.list('products', {
+     *   where: { active: true },
+     *   populate: ['categoryId', 'brandId'],
+     *   limit: 10,
+     * });
+     * // Each product has .category and .brand objects
+     *
+     * // Nested populate
+     * const orders = await db.list('orders', {
+     *   populate: [
+     *     'userId',
+     *     { path: 'items', populate: ['productId'] }
+     *   ]
+     * });
+     * ```
+     */
+    list<T = unknown>(table: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Get single record by ID
+     *
+     * @example
+     * ```typescript
+     * const product = await db.get('products', 1, {
+     *   populate: ['categoryId']
+     * });
+     * console.log(product.category.name);
+     * ```
+     */
+    get<T = unknown>(table: string, id: string | number, options?: QueryOptions): Promise<T | null>;
+    /**
+     * Count records
+     */
+    count(table: string, options?: QueryOptions): Promise<number>;
+    /**
+     * Paginated query
+     */
+    paginate<T = unknown>(table: string, page: number, limit: number, options?: QueryOptions): Promise<PaginatedResult<T>>;
+    /**
+     * Create new record
+     */
+    create<T = unknown>(table: string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Update record by ID
+     */
+    update<T = unknown>(table: string, id: string | number, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Delete record by ID
+     */
+    delete(table: string, id: string | number): Promise<boolean>;
+    /**
+     * Create multiple records
+     */
+    createMany<T = unknown>(table: string, records: Record<string, unknown>[], options?: {
+        ignore?: boolean;
+    }): Promise<{
+        created: number;
+        ids: (number | bigint)[];
+    }>;
+    /**
+     * Update multiple records
+     */
+    updateMany(table: string, updates: {
+        id: number | string;
+        data: Record<string, unknown>;
+    }[]): Promise<{
+        updated: number;
+    }>;
+    /**
+     * Delete multiple records
+     */
+    deleteMany(table: string, ids: (number | string)[]): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Execute raw query
+     */
+    raw<T = unknown>(query: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Execute raw statement
+     */
+    execute(query: string, params?: unknown[]): Promise<{
+        changes: number;
+        lastInsertRowid: number | bigint;
+    }>;
+    /**
+     * Transaction wrapper
+     *
+     * @example
+     * ```typescript
+     * await db.transaction(async (tx) => {
+     *   const user = await tx.create('users', { name: 'John' });
+     *   await tx.create('posts', { title: 'Hello', userId: user.id });
+     * });
+     * ```
+     */
+    transaction<T>(callback: (orm: ORM) => Promise<T>): Promise<T>;
+    /**
+     * Get all table names
+     */
+    getTables(): Promise<string[]>;
+    /**
+     * Get table schema
+     */
+    getTableSchema(table: string): Promise<unknown[]>;
+    /**
+     * Close connection
+     */
+    close(): Promise<void>;
+    /**
+     * Normalize query options
+     */
+    private normalizeOptions;
+    /**
+     * Validate data against schema
+     */
+    private validateData;
+    /**
+     * Resolve populate for records
+     */
+    private resolvePopulateForRecords;
+    /**
+     * Get the underlying adapter (for advanced usage)
+     */
+    getAdapter(): IDataAdapter;
+    /**
+     * Get current schema (if set)
+     */
+    getSchema(): SchemaDefinition | undefined;
+    /**
+     * Set schema
+     */
+    setSchema(schema: SchemaDefinition): void;
+}

package/dist/adapters/IDataAdapter.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Data Adapter Interface
+ *
+ * All data sources must implement this interface.
+ * This is the contract between ORM and adapters.
+ *
+ * Features:
+ * - Built-in multi-language support via lang option
+ * - Automatic translation handling for translatable fields
+ * - MongoDB-style populate for references
+ */
+import type { QueryOptions, PaginatedResult, SchemaDefinition } from "../types";
+/**
+ * Generic Data Adapter Interface
+ */
+export interface IDataAdapter {
+    /**
+     * Schema definition for translation support (optional)
+     */
+    schema?: SchemaDefinition;
+    /**
+     * Default language for translations
+     */
+    defaultLang?: string;
+    /**
+     * Set schema after construction
+     */
+    setSchema?(schema: SchemaDefinition): void;
+    /**
+     * Initialize the adapter (optional)
+     */
+    connect?(): void | Promise<void>;
+    /**
+     * List records from table
+     */
+    list<T = unknown>(table: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Get single record by ID
+     */
+    get<T = unknown>(table: string, id: string | number, options?: QueryOptions): Promise<T | null>;
+    /**
+     * Count records matching condition
+     */
+    count(table: string, options?: QueryOptions): Promise<number>;
+    /**
+     * Query with pagination
+     */
+    paginate<T = unknown>(table: string, page: number, limit: number, options?: QueryOptions): Promise<PaginatedResult<T>>;
+    /**
+     * Create new record
+     */
+    create<T = unknown>(table: string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Update record by ID
+     */
+    update<T = unknown>(table: string, id: string | number, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Delete record by ID
+     */
+    delete(table: string, id: string | number): Promise<boolean>;
+    /**
+     * Create multiple records
+     */
+    createMany<T = unknown>(table: string, records: Record<string, unknown>[], options?: {
+        ignore?: boolean;
+    }): Promise<{
+        created: number;
+        ids: (number | bigint)[];
+    }>;
+    /**
+     * Update multiple records
+     */
+    updateMany(table: string, updates: {
+        id: number | string;
+        data: Record<string, unknown>;
+    }[]): Promise<{
+        updated: number;
+    }>;
+    /**
+     * Delete multiple records
+     */
+    deleteMany(table: string, ids: (number | string)[]): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Create record with translations in a single transaction
+     * If translations not provided but data contains translatable fields,
+     * those fields are automatically added as defaultLang translation
+     */
+    createWithTranslations<T = unknown>(table: string, data: Record<string, unknown>, translations?: Record<string, Record<string, unknown>>): Promise<T>;
+    /**
+     * Update or insert translation for specific language
+     */
+    upsertTranslation(table: string, id: string | number, lang: string, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Get all translations for a record
+     */
+    getTranslations<T = unknown>(table: string, id: string | number): Promise<T[]>;
+    /**
+     * Execute raw query (adapter-specific)
+     */
+    raw<T = unknown>(query: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Execute raw statement (for INSERT/UPDATE/DELETE)
+     */
+    execute(query: string, params?: unknown[]): Promise<{
+        changes: number;
+        lastInsertRowid: number | bigint;
+    }>;
+    /**
+     * Begin transaction
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * Commit transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback transaction
+     */
+    rollback(): Promise<void>;
+    /**
+     * Get all table names
+     */
+    getTables?(): Promise<string[]>;
+    /**
+     * Get table schema/structure
+     */
+    getTableSchema?(table: string): Promise<unknown[]>;
+    /**
+     * Close connection
+     */
+    close(): void | Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @promakeai/orm - Database-Agnostic ORM
+ *
+ * Works in browser and Node.js with any adapter implementing IDataAdapter.
+ *
+ * @example
+ * ```typescript
+ * import { ORM, defineSchema, f } from '@promakeai/orm';
+ *
+ * // Define schema
+ * const schema = defineSchema({
+ *   languages: ['en', 'tr'],
+ *   tables: {
+ *     products: {
+ *       id: f.id(),
+ *       name: f.string().translatable().required(),
+ *       price: f.decimal().required(),
+ *       categoryId: f.int().ref('categories'),
+ *     },
+ *     categories: {
+ *       id: f.id(),
+ *       name: f.string().translatable().required(),
+ *     },
+ *   },
+ * });
+ *
+ * // Use with adapter
+ * const db = new ORM(adapter, { schema });
+ * const products = await db.list('products', {
+ *   where: { price: { $gt: 100 } },
+ *   populate: ['categoryId'],
+ * });
+ * ```
+ */
+export { ORM } from "./ORM";
+export type { IDataAdapter } from "./adapters/IDataAdapter";
+export { defineSchema, f, mergeSchemas, createSchemaUnsafe, } from "./schema";
+export type { FieldBuilder } from "./schema";
+export { validateSchema, assertValidSchema, isValidSchema, validateTable, ValidationErrorCode, } from "./schema";
+export type { ValidationError } from "./schema";
+export { singularize, pluralize, toPascalCase, toCamelCase, toSnakeCase, toInterfaceName, toDbInterfaceName, toPascalCasePlural, toTranslationTableName, toTranslationFKName, } from "./schema";
+export { getTranslatableFields, getNonTranslatableFields, getInsertableFields, hasTranslatableFields, getPrimaryKeyField, getReferenceFields, getMainTableFields, getTranslationTableFields, isRequiredField, getRequiredFields, getRefTarget, getRefTargetFull, } from "./schema";
+export { buildWhereClause } from "./utils/whereBuilder";
+export type { WhereResult } from "./utils/whereBuilder";
+export { buildTranslationQuery, buildTranslationQueryById, buildTranslationInsert, buildTranslationUpsert, extractTranslatableData, } from "./utils/translationQuery";
+export type { TranslationQueryOptions, TranslationQueryResult, } from "./utils/translationQuery";
+export { resolvePopulate, getPopulatableFields, validatePopulate, } from "./utils/populateResolver";
+export type { PopulateAdapter } from "./utils/populateResolver";
+export { parseJSONSchema } from "./utils/jsonConverter";
+export type { FieldType, FieldDefinition, FieldReference, FieldBuilderLike, TableDefinition, LanguageConfig, SchemaDefinition, SchemaInput, JSONFieldDefinition, JSONTableDefinition, JSONSchemaDefinition, WhereCondition, OrderByOption, PopulateOption, PopulateNested, QueryOptions, PaginatedResult, ORMConfig, } from "./types";