@indexeddb-orm/idb-orm 0.0.1

package/dist/decorators/Relation.d.ts

@@ -0,0 +1,70 @@
+import type { ClassConstructor } from '../services/DecoratorUtils';
+import type { EntityConstructor, RelationMetadata, RelationOptions } from '../types';
+/**
+ * Relation decorator: defines a relation on a
+ * property (one-to-one/many-to-one/etc.).
+ * @param options - Relation options
+ * (type, target, foreignKey/joinTable, cascade, eager)
+ * @returns Property decorator function
+ *
+ * @example
+ * class Post {
+ *   @Relation({ type: 'many-to-many', target: 'tags', joinTable: 'post_tags' })
+ *   tags?: Tag[];
+ * }
+ */
+export declare function Relation(options: RelationOptions): (...args: unknown[]) => void;
+/**
+ * Retrieve relation metadata for an entity class.
+ * @param entityClass - The entity class (constructor)
+ * @returns Map of propertyKey -> RelationMetadata, or undefined if none
+ *
+ * @example
+ * const relations = getRelationMetadata(User);
+ */
+export declare function getRelationMetadata(entityClass: ClassConstructor): Record<string, RelationMetadata> | undefined;
+/**
+ * Convenience decorator for one-to-one relations.
+ * @param params - target, optional foreignKey, and extra options
+ * @returns Property decorator function
+ *
+ * @example
+ * class User {
+ * @OneToOne({ target: 'profiles', foreignKey: 'userId' }) profile?: Profile
+ * }
+ */
+export declare function OneToOne(params: {
+    target: EntityConstructor | string;
+    foreignKey?: string;
+    options?: Partial<RelationOptions>;
+}): (...args: unknown[]) => void;
+/**
+ * Convenience decorator for one-to-many relations.
+ * @param params - target, required foreignKey, and extra options
+ * @returns Property decorator function
+ *
+ * @example
+ * class User { @OneToMany(
+ * { target: 'posts', foreignKey: 'authorId' }) posts?: Post[]
+ * }
+ */
+export declare function OneToMany(params: {
+    target: EntityConstructor | string;
+    foreignKey: string;
+    options?: Partial<RelationOptions>;
+}): (...args: unknown[]) => void;
+/**
+ * Convenience decorator for many-to-many relations.
+ * @param params - target, joinTable, and extra options
+ * @returns Property decorator function
+ *
+ * @example
+ * class Post {
+ * @ManyToMany({ target: 'tags', joinTable: 'post_tags' }) tags?: Tag[]
+ * }
+ */
+export declare function ManyToMany(params: {
+    target: EntityConstructor | string;
+    joinTable: string;
+    options?: Partial<RelationOptions>;
+}): (...args: unknown[]) => void;

package/dist/decorators/Relation.js

@@ -0,0 +1,120 @@
+// reflect-metadata no longer required
+import { isFieldContext, isLegacyArgs, } from '../services/DecoratorUtils';
+import { getDefinedRelations } from '../services/EntityRegistry';
+const RELATIONS_METADATA_KEY = Symbol('relations');
+/**
+ * Relation decorator: defines a relation on a
+ * property (one-to-one/many-to-one/etc.).
+ * @param options - Relation options
+ * (type, target, foreignKey/joinTable, cascade, eager)
+ * @returns Property decorator function
+ *
+ * @example
+ * class Post {
+ *   @Relation({ type: 'many-to-many', target: 'tags', joinTable: 'post_tags' })
+ *   tags?: Tag[];
+ * }
+ */
+export function Relation(options) {
+    return function (...args) {
+        const apply = (ctor, propertyKey) => {
+            const existingRelations = getRelationMetadata(ctor) || {};
+            const relationMetadata = { propertyKey, ...options };
+            existingRelations[propertyKey] = relationMetadata;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const reflectDefine = Reflect?.defineMetadata?.bind(Reflect);
+            if (reflectDefine) {
+                reflectDefine(RELATIONS_METADATA_KEY, existingRelations, ctor);
+            }
+        };
+        // Legacy TS decorators
+        if (isLegacyArgs(args)) {
+            const [target, propertyKey] = args;
+            apply(target.constructor, propertyKey);
+            return;
+        }
+        // Standard decorators (TC39)
+        if (isFieldContext(args)) {
+            const [, context] = args;
+            const propertyKey = context.name;
+            context.addInitializer(function () {
+                apply(this.constructor, propertyKey);
+            });
+        }
+    };
+}
+/**
+ * Retrieve relation metadata for an entity class.
+ * @param entityClass - The entity class (constructor)
+ * @returns Map of propertyKey -> RelationMetadata, or undefined if none
+ *
+ * @example
+ * const relations = getRelationMetadata(User);
+ */
+export function getRelationMetadata(entityClass) {
+    const defined = getDefinedRelations(entityClass);
+    if (defined) {
+        const out = {};
+        for (const [key, rel] of Object.entries(defined)) {
+            out[key] = { propertyKey: key, ...rel };
+        }
+        return out;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reflectGet = Reflect?.getMetadata?.bind(Reflect);
+    return reflectGet ? (reflectGet(RELATIONS_METADATA_KEY, entityClass) || {}) : {};
+}
+/**
+ * Convenience decorator for one-to-one relations.
+ * @param params - target, optional foreignKey, and extra options
+ * @returns Property decorator function
+ *
+ * @example
+ * class User {
+ * @OneToOne({ target: 'profiles', foreignKey: 'userId' }) profile?: Profile
+ * }
+ */
+export function OneToOne(params) {
+    return Relation({
+        type: 'one-to-one',
+        target: params.target,
+        foreignKey: params.foreignKey,
+        ...params.options,
+    });
+}
+/**
+ * Convenience decorator for one-to-many relations.
+ * @param params - target, required foreignKey, and extra options
+ * @returns Property decorator function
+ *
+ * @example
+ * class User { @OneToMany(
+ * { target: 'posts', foreignKey: 'authorId' }) posts?: Post[]
+ * }
+ */
+export function OneToMany(params) {
+    return Relation({
+        type: 'one-to-many',
+        target: params.target,
+        foreignKey: params.foreignKey,
+        ...params.options,
+    });
+}
+/**
+ * Convenience decorator for many-to-many relations.
+ * @param params - target, joinTable, and extra options
+ * @returns Property decorator function
+ *
+ * @example
+ * class Post {
+ * @ManyToMany({ target: 'tags', joinTable: 'post_tags' }) tags?: Tag[]
+ * }
+ */
+export function ManyToMany(params) {
+    return Relation({
+        type: 'many-to-many',
+        target: params.target,
+        joinTable: params.joinTable,
+        ...params.options,
+    });
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export { Column, CompoundIndex, getColumnMetadata, getCompoundIndexMetadata, Index, PrimaryKey, Unique, } from './Column';
+export { Entity, getEntityMetadata, } from './Entity';
+export { getRelationMetadata, ManyToMany, OneToMany, OneToOne, Relation, } from './Relation';

package/dist/decorators/index.js

@@ -0,0 +1,3 @@
+export { Column, CompoundIndex, getColumnMetadata, getCompoundIndexMetadata, Index, PrimaryKey, Unique, } from './Column';
+export { Entity, getEntityMetadata, } from './Entity';
+export { getRelationMetadata, ManyToMany, OneToMany, OneToOne, Relation, } from './Relation';

package/dist/errors/ValidationError.d.ts

@@ -0,0 +1,4 @@
+export declare class ValidationError extends Error {
+    errors: string[];
+    constructor(message: string, errors?: string[]);
+}

package/dist/errors/ValidationError.js

@@ -0,0 +1,8 @@
+export class ValidationError extends Error {
+    errors;
+    constructor(message, errors = []) {
+        super(message);
+        this.name = 'ValidationError';
+        this.errors = errors;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Database } from './Database';
+export { ValidationError } from './errors/ValidationError';
+export { Entity, ManyToMany, OneToMany, OneToOne, Relation, } from './metadata';
+export { BaseEntity } from './services/BaseEntity';
+export { newEntity } from './services/EntityFactory';
+export { defineEntity } from './services/EntityRegistry';
+export { EntitySchema } from './services/EntitySchema';
+export type { CloudSyncConfig, DatabaseConfig, EntityConstructor, EntityInstance, } from './types';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { Database } from './Database';
+export { ValidationError } from './errors/ValidationError';
+export { Entity, ManyToMany, OneToMany, OneToOne, Relation, } from './metadata';
+export { BaseEntity } from './services/BaseEntity';
+export { newEntity } from './services/EntityFactory';
+export { defineEntity } from './services/EntityRegistry';
+export { EntitySchema } from './services/EntitySchema';

package/dist/metadata/Column.d.ts

@@ -0,0 +1,8 @@
+type ClassConstructor<T = unknown> = abstract new (..._args: never[]) => T;
+import type { ColumnOptions, CompoundIndexOptions } from '../types';
+export interface ColumnMetadata extends ColumnOptions {
+    propertyKey: string;
+}
+export declare function getColumnMetadata(target: object | ClassConstructor): Record<string, ColumnMetadata>;
+export declare function getCompoundIndexMetadata(target: object | ClassConstructor): CompoundIndexOptions[];
+export {};

package/dist/metadata/Column.js

@@ -0,0 +1,44 @@
+import { getDefinedColumns, getDefinedCompoundIndexes, } from '../services/EntityRegistry';
+const COLUMNS_METADATA_KEY = Symbol('columns');
+const COMPOUND_INDEXES_METADATA_KEY = Symbol('compoundIndexes');
+export function getColumnMetadata(target) {
+    const ctor = (typeof target === 'function')
+        ? target
+        : target.constructor;
+    const defined = getDefinedColumns(ctor);
+    if (defined) {
+        const out = {};
+        for (const [key, cfg] of Object.entries(defined)) {
+            out[key] = { propertyKey: key, ...cfg };
+        }
+        const hasPrimary = Object.values(out).some(c => c.primaryKey);
+        if (!hasPrimary) {
+            if (!out.id) {
+                out.id = { propertyKey: 'id', primaryKey: true, autoIncrement: true };
+            }
+            else {
+                out.id.primaryKey = true;
+                if (out.id.autoIncrement === undefined) {
+                    out.id.autoIncrement = true;
+                }
+            }
+        }
+        return out;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reflectGet = Reflect?.getMetadata?.bind(Reflect);
+    return reflectGet ? (reflectGet(COLUMNS_METADATA_KEY, ctor) || {}) : {};
+}
+export function getCompoundIndexMetadata(target) {
+    const ctor = (typeof target === 'function')
+        ? target
+        : target.constructor;
+    const defined = getDefinedCompoundIndexes(ctor);
+    if (defined) {
+        return defined
+            .map(ci => ({ name: ci.name, unique: ci.unique, columns: ci.columns }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reflectGet = Reflect?.getMetadata?.bind(Reflect);
+    return reflectGet ? (reflectGet(COMPOUND_INDEXES_METADATA_KEY, ctor) || []) : [];
+}

package/dist/metadata/Entity.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+type ClassConstructor<T = unknown> = abstract new (..._args: never[]) => T;
+import type { EntityOptions } from '../types';
+export interface EntityMetadata {
+    tableName: string;
+    schema?: z.ZodSchema<unknown>;
+    timestamps?: boolean;
+}
+export declare function Entity(_options?: EntityOptions): (_target: ClassConstructor) => void;
+export declare function getEntityMetadata(target: ClassConstructor): EntityMetadata | undefined;
+export {};

package/dist/metadata/Entity.js

@@ -0,0 +1,21 @@
+import { getDefinedEntityMeta } from '../services/EntityRegistry';
+const ENTITY_METADATA_KEY = Symbol('entity');
+export function Entity(_options = {}) {
+    return function (_target) { };
+}
+export function getEntityMetadata(target) {
+    const defined = getDefinedEntityMeta(target);
+    if (defined) {
+        return {
+            tableName: defined.tableName,
+            schema: defined.schema,
+            timestamps: defined.timestamps,
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reflectGet = Reflect?.getMetadata?.bind(Reflect);
+    if (reflectGet) {
+        return reflectGet(ENTITY_METADATA_KEY, target);
+    }
+    return undefined;
+}

package/dist/metadata/Relation.d.ts

@@ -0,0 +1,20 @@
+type ClassConstructor<T = unknown> = abstract new (..._args: never[]) => T;
+import type { EntityConstructor, RelationMetadata, RelationOptions } from '../types';
+export declare function Relation(options: RelationOptions): (..._args: unknown[]) => void;
+export declare function getRelationMetadata(entityClass: ClassConstructor): Record<string, RelationMetadata> | undefined;
+export declare function OneToOne(params: {
+    target: EntityConstructor | string;
+    foreignKey?: string;
+    options?: Partial<RelationOptions>;
+}): (..._args: unknown[]) => void;
+export declare function OneToMany(params: {
+    target: EntityConstructor | string;
+    foreignKey: string;
+    options?: Partial<RelationOptions>;
+}): (..._args: unknown[]) => void;
+export declare function ManyToMany(params: {
+    target: EntityConstructor | string;
+    joinTable: string;
+    options?: Partial<RelationOptions>;
+}): (..._args: unknown[]) => void;
+export {};

package/dist/metadata/Relation.js

@@ -0,0 +1,74 @@
+function isLegacyArgs(args) {
+    return Array.isArray(args) && typeof args[1] === 'string';
+}
+function isFieldContext(args) {
+    const ctx = args[1];
+    return !!ctx && typeof ctx === 'object' && ctx.kind === 'field' && typeof ctx.name === 'string';
+}
+import { getDefinedRelations } from '../services/EntityRegistry';
+const RELATIONS_METADATA_KEY = Symbol('relations');
+export function Relation(options) {
+    return function (...args) {
+        const apply = (ctor, propertyKey) => {
+            const existingRelations = getRelationMetadata(ctor) || {};
+            const relationMetadata = { propertyKey, ...options };
+            existingRelations[propertyKey] = relationMetadata;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const reflectDefine = Reflect?.defineMetadata?.bind(Reflect);
+            if (reflectDefine) {
+                reflectDefine(RELATIONS_METADATA_KEY, existingRelations, ctor);
+            }
+        };
+        if (isLegacyArgs(args)) {
+            const [target, propertyKey] = args;
+            apply(target.constructor, propertyKey);
+            return;
+        }
+        if (isFieldContext(args)) {
+            const [, context] = args;
+            const propertyKey = context.name;
+            context.addInitializer(function (_this) {
+                apply(_this.constructor, propertyKey);
+            });
+        }
+    };
+}
+export function getRelationMetadata(entityClass) {
+    const defined = getDefinedRelations(entityClass);
+    if (defined) {
+        const out = {};
+        for (const [key, rel] of Object.entries(defined)) {
+            out[key] = { propertyKey: key, ...rel };
+        }
+        return out;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reflectGet = Reflect?.getMetadata?.bind(Reflect);
+    return reflectGet
+        ? (reflectGet(RELATIONS_METADATA_KEY, entityClass) || {})
+        : {};
+}
+export function OneToOne(params) {
+    return Relation({
+        type: 'one-to-one',
+        target: params.target,
+        foreignKey: params.foreignKey,
+        ...params.options,
+    });
+}
+export function OneToMany(params) {
+    return Relation({
+        type: 'one-to-many',
+        target: params.target,
+        foreignKey: params.foreignKey,
+        ...params.options,
+    });
+}
+export function ManyToMany(params) {
+    return Relation({
+        type: 'many-to-many',
+        target: params.target,
+        joinTable: params.joinTable,
+        ...params.options,
+    });
+}

package/dist/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Column';
+export * from './Entity';
+export * from './Relation';

package/dist/metadata/index.js

@@ -0,0 +1,3 @@
+export * from './Column';
+export * from './Entity';
+export * from './Relation';

package/dist/services/AggregationService.d.ts

@@ -0,0 +1,38 @@
+import type { Database } from '../Database';
+import type { AggregationOptions, AggregationResult, EntityConstructor } from '../types';
+import { BaseEntity } from './BaseEntity';
+export declare class AggregationService {
+    private db;
+    constructor(database: Database);
+    /**
+     * Perform aggregation operations on entity data
+     * @param entityClass - The entity class to aggregate
+     * @param options - Aggregation options including filters, sorting, grouping, etc.
+     * @returns Promise resolving to aggregation results
+     *
+     * @example
+     * const result = await aggregationService.aggregate(Post, {
+     *   where: { category: 'tech' },
+     *   sort: { field: 'views', direction: 'desc' },
+     *   limit: 10,
+     *   count: true,
+     *   sum: ['views'],
+     * });
+     */
+    aggregate<T extends BaseEntity>(entityClass: EntityConstructor<T>, options: AggregationOptions<T>): Promise<AggregationResult>;
+    /**
+     * Load a specific relation based on metadata.
+     * @param entity - The source entity to load relation for
+     * @param relationMeta - Relation metadata (type, target, keys)
+     * @returns Promise resolving to the loaded relation data
+     *
+     * @example
+     * const related = await (aggregationService as any).loadRelation(record, {
+     *   type: 'one-to-many', target: Post, foreignKey: 'authorId',
+     * });
+     */
+    private loadRelation;
+    private loadOneToOne;
+    private loadOneToMany;
+    private loadManyToMany;
+}