@nx-ddd/firestore 19.2.1 → 19.3.1

package/index.d.ts

@@ -1,7 +1,424 @@
-export * from './adapters';
-export * from './converter';
-export * from './dao';
-export * from './decorators';
-export * from './path-builder';
-export * from './query';
-export * from './repository';
+import { QueryDocumentSnapshot } from 'firebase-admin/firestore';
+import { Observable, ReplaySubject } from 'rxjs';
+import * as i0 from '@angular/core';
+import * as dayjs from 'dayjs';
+import dayjs__default from 'dayjs';
+import Dexie from 'dexie';
+import { Repository } from '@nx-ddd/common/domain';
+
+type DocumentData = {
+    [field: string]: any;
+};
+interface GetOptions {
+    readonly source?: 'default' | 'server' | 'cache';
+}
+interface DocumentChangeAction<T> {
+    type: any;
+    payload: {
+        doc: DocumentSnapshot<T>;
+    };
+}
+interface DocumentSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
+    id: string;
+    ref: {
+        path: string;
+    };
+    data: () => AppModelType | undefined;
+    get: (fieldPath: string) => any;
+    exists?: (() => boolean) | boolean;
+}
+interface QuerySnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
+    docs: Array<QueryDocumentSnapshot<AppModelType, DbModelType>>;
+}
+interface Timestamp {
+    readonly seconds: number;
+    readonly nanoseconds: number;
+    toDate(): Date;
+    toMillis(): number;
+    isEqual(other: Timestamp): boolean;
+    valueOf(): string;
+}
+interface TimestampConstructor {
+    new (seconds: number, nanoseconds: number): Timestamp;
+    now(): Timestamp;
+    fromDate(date: Date): Timestamp;
+    fromMillis(milliseconds: number): Timestamp;
+}
+type FieldValue = any;
+type ToFirestoreData<Entity, Date> = {
+    [K in keyof Entity]: Entity[K] extends Date ? Timestamp | FieldValue : Entity[K];
+};
+interface DocumentReference<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> {
+    __ref?: Origin;
+    exists(): Promise<boolean>;
+    set(data: AppModelType, options?: any): Promise<void | any>;
+    get(): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
+    update(data: AppModelType): Promise<void | any>;
+    delete(): Promise<void | any>;
+    stateChanges?: () => Observable<DocumentSnapshot<AppModelType, DbModelType>>;
+}
+type CollectionReference<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> = Query<AppModelType, DbModelType, Origin>;
+type CollectionGroup<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> = Query<AppModelType, DbModelType, Origin>;
+interface Query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> {
+    __ref?: Origin;
+    stateChanges?: () => Observable<DocumentChangeAction<DocumentData>[]>;
+    get(options?: GetOptions): Promise<QuerySnapshot<AppModelType, DbModelType>>;
+    onSnapshot?(onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void): () => void;
+    count(): Promise<number>;
+}
+type CollectionLike<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData, Origin = any> = CollectionReference<AppModelType, DbModelType, Origin> | CollectionGroup<AppModelType, DbModelType, Origin> | Query<AppModelType, DbModelType, Origin>;
+
+declare class DateAdapter {
+    isDate<D>(value: any): value is D;
+    isValid(value: any): boolean;
+    getJsDate<D>(value: any): D;
+    convertToDate<D>(value: Date): D;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateAdapter>;
+}
+
+type QueryFn<AppModelType, DbModelType, R> = (collection?: any) => R;
+type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'in' | 'array-contains-any' | 'not-in';
+declare abstract class FirestoreAdapter<Date = any> {
+    protected dateAdapter: DateAdapter;
+    protected abstract isTimestamp(v: any): v is Timestamp;
+    protected abstract isFieldValue(v: any): v is FieldValue;
+    abstract get Timestamp(): any;
+    abstract get FieldValue(): any;
+    abstract get FieldPath(): any;
+    abstract doc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(path: string): DocumentReference<AppModelType>;
+    abstract collection<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(path: string): CollectionReference<AppModelType, DbModelType>;
+    abstract collectionGroup<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collectionId: string): CollectionGroup<AppModelType, DbModelType>;
+    abstract query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collection: CollectionReference<AppModelType, DbModelType>, ...queryFnArray: QueryFn<AppModelType, DbModelType, any>[]): Query<AppModelType, DbModelType>;
+    abstract where<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(key: string, evaluation: WhereFilterOp, value: unknown): QueryFn<AppModelType, DbModelType, any>;
+    abstract orderBy<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(key: string, order: 'asc' | 'desc'): QueryFn<AppModelType, DbModelType, any>;
+    abstract limit<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(n: number): QueryFn<AppModelType, DbModelType, any>;
+    abstract runTransaction(fn: any): any;
+    abstract batch(): any;
+    toFirestoreData<Entity>(entity: Entity): ToFirestoreData<Entity, Date>;
+    fromFirestoreData<Entity>(data: ToFirestoreData<Entity, Date>): Entity;
+    toFirestore<T>(obj: object, Entity: new () => T): object;
+    fromFirestore<T = any>(data: any, Entity: new () => T): T;
+    /**
+     * @description FirestoreのUpdateは通常のオブジェクトでは孫以下のプロパティが既存データとマージされないので、パスに変換する必要がある。
+     */
+    flattenForUpdate(obj: any): any;
+    convertDateToTimestamp(date: Date): Timestamp;
+    convertTimestampToDate(timestamp: Timestamp): Date;
+}
+declare function provideFirestoreAdapter(useClass: new () => FirestoreAdapter): {
+    provide: typeof FirestoreAdapter;
+    useClass: new () => FirestoreAdapter;
+};
+
+interface IFirestoreConverter<E extends {
+    id: string;
+}> {
+    fromFirestore(doc: DocumentSnapshot<object>): E;
+    fromFirestoreMany(docs: DocumentSnapshot<object>[]): E[];
+    toFirestore(entity: Partial<E>): object;
+    fromObject?(obj: object): E;
+    toObject?(entity: E): object;
+}
+declare function getConverter<Entity extends {
+    id: string;
+}>(Entity: new () => Entity, adapter?: FirestoreAdapter): IFirestoreConverter<Entity>;
+declare function injectConverter<Entity extends {
+    id: string;
+}>(Entity: new () => Entity): IFirestoreConverter<Entity>;
+
+type CollectionParamMap<Entity extends {
+    id: string;
+}> = Partial<Entity>;
+type DocParamMap<Entity extends {
+    id: string;
+}> = CollectionParamMap<Entity> & Pick<Entity, 'id'>;
+type ExtractParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof ExtractParams<Rest>]: string;
+} : T extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : {};
+type ColParam$3<T extends {
+    readonly collectionPath: string;
+}> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
+type DocParam$2<T extends {
+    readonly collectionPath: string;
+}> = ColParam$3<T> & {
+    id: string;
+};
+declare class FirestorePathBuilder<Entity extends {
+    id: string;
+}, Path extends string = string> {
+    private paths;
+    doc(param: DocParamMap<Entity>): string;
+    collection(param?: Omit<ExtractParams<Path>, 'id'> | {}): string;
+    collectionGroup(): string;
+    constructor(paths: string[]);
+}
+declare function pathBuilderFactory<E extends {
+    id: string;
+}, Path extends string = string>(path: Path): FirestorePathBuilder<E, Path>;
+declare function parsePath<Path extends string = string>(path: Path): string[];
+declare const resolvePaths: (obj: object, paths: string[]) => string;
+
+declare class FirestoreDAO<Entity extends {
+    id: string;
+}, FirestoreData = ToFirestoreData<Entity, dayjs__default.Dayjs>> {
+    protected adapter: FirestoreAdapter;
+    protected pathBuilder: FirestorePathBuilder<Entity>;
+    constructor(adapter: FirestoreAdapter, pathBuilder: FirestorePathBuilder<Entity>);
+    collection(paramMap?: Partial<Entity>): CollectionReference<FirestoreData>;
+    collectionGroup(): CollectionGroup<FirestoreData>;
+    doc(paramMap: Partial<Entity> & {
+        id: string;
+    }): DocumentReference<FirestoreData>;
+    getCollection(paramMap?: Partial<Entity>): CollectionLike;
+}
+
+declare const FIRESTORE_ANNOTATIONS = "firestore_annotations";
+type FirestoreFieldType = 'id' | 'boolean' | 'number' | 'timestamp' | 'string' | 'geopoint' | 'null' | 'map' | 'array' | 'reference';
+interface FirestoreAnnotation {
+    type: FirestoreFieldType;
+    fieldName: string;
+    propName: string;
+    childType: any;
+}
+declare const createDecorator: (type: FirestoreFieldType, options?: {
+    childType?: any;
+}) => (nameOrProps?: {
+    name?: string;
+} | string) => (target: any, propName: string) => void;
+declare const createPropsDecorator: (type: FirestoreFieldType, options?: {
+    childType?: any;
+}) => (nameOrProps?: {
+    name?: string;
+} | string) => (target: any, propName: string) => void;
+declare const createClassDecorator: <Props extends {
+    name: string;
+}>(type: string) => (nameOrProps: Props | string) => (target: any) => void;
+declare const getAnnotations: (target: any) => FirestoreAnnotation[];
+/** @deprecated use getAnnotations */
+declare function getFirestoreAnnotations(target: any): FirestoreAnnotation[];
+declare function getCollection(target: any): string;
+declare const Firestore: {
+    Collection: (nameOrProps: string | {
+        name: string;
+    }) => (target: any) => void;
+    ID: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    String: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Null: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Geopoint: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Boolean: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Timestamp: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Number: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Map: (childType?: () => any, props?: {
+        name?: string;
+    }) => (target: any, propName: string) => void;
+    Array: (childType?: () => any, props?: {
+        name?: string;
+    }) => (target: any, propName: string) => void;
+    Reference: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+};
+
+declare class FirestoreQuery$1<Entity extends {
+    id: string;
+} = any, FirestoreData = ToFirestoreData<Entity, dayjs__default.Dayjs>> extends FirestoreDAO<Entity, FirestoreData> {
+    protected converter: IFirestoreConverter<Entity>;
+    protected pathBuilder: FirestorePathBuilder<Entity>;
+    constructor(adapter: FirestoreAdapter, converter: IFirestoreConverter<Entity>, pathBuilder: FirestorePathBuilder<Entity>);
+    protected readonly collection$: ReplaySubject<CollectionLike<FirestoreData>>;
+    protected readonly list$: Observable<Entity[]>;
+    /** @deprecated */
+    listChanges(paramMap?: Partial<Entity>, options?: {
+        switch?: boolean;
+    }): Observable<Entity[]>;
+    listChangesV2(paramMap?: Partial<Entity>): Observable<Entity[]>;
+    listChangesAfter(updatedAt: dayjs__default.Dayjs, { limit }?: {
+        limit?: number;
+    }): Observable<Entity[]>;
+    changes({ id }: Partial<Entity>): Observable<Entity>;
+    changesV2(params: Partial<Entity>): Observable<Entity>;
+    get({ id }: Partial<Entity> & {
+        id: string;
+    }): Promise<Entity>;
+    list(paramMap?: Partial<Entity>): Promise<Entity[]>;
+    protected listChangesByCollectionRef(collection: CollectionReference<FirestoreData> | CollectionGroup<FirestoreData>): Observable<Entity[]>;
+    protected switchCollectionRef(paramMap?: Partial<Entity>): void;
+    switchCollection(collection: CollectionLike<any>): void;
+}
+
+type ColParam$2<T extends BaseFirestoreQuery<any>> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
+type DocParam$1<T extends BaseFirestoreQuery<any>> = ColParam$2<T> & {
+    id: string;
+};
+declare abstract class BaseFirestoreQuery<Entity extends {
+    id: string;
+} = any> {
+    protected abstract readonly adapter: FirestoreAdapter;
+    protected abstract readonly converter: IFirestoreConverter<Entity>;
+    abstract readonly collectionPath: string;
+    protected abstract pathBuilder: FirestorePathBuilder<Entity, typeof this.collectionPath>;
+    protected abstract dao: FirestoreDAO<Entity>;
+    count(paramMap?: ColParam$2<this>): Promise<number>;
+    changes(params: DocParam$1<this>): Observable<Entity>;
+    get(paramMap: DocParam$1<this>): Promise<Entity>;
+    list(paramMap?: ColParam$2<this>): Promise<Entity[]>;
+    listChanges(paramMap?: ColParam$2<this>): Observable<Entity[]>;
+    protected getChanges$ByDocument(doc: DocumentReference): Observable<Entity>;
+    protected getListChanges$ByCollectionLike(collection: CollectionLike): Observable<Entity[]>;
+}
+declare abstract class FirestoreQuery<Entity extends {
+    id: string;
+} = any> extends BaseFirestoreQuery<Entity> {
+    protected readonly adapter: FirestoreAdapter<any>;
+    abstract readonly collectionPath: string;
+    protected abstract readonly converter: IFirestoreConverter<Entity>;
+    get pathBuilder(): FirestorePathBuilder<Entity, typeof this.collectionPath>;
+    protected get dao(): FirestoreDAO<Entity, ToFirestoreData<Entity, dayjs.Dayjs>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreQuery<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreQuery<any>>;
+}
+declare function getFirestoreQuery<Entity extends {
+    id: string;
+}>(entity: {
+    new (): Entity;
+}, adapter?: FirestoreAdapter): BaseFirestoreQuery<Entity>;
+declare function injectFirestoreQuery<Entity extends {
+    id: string;
+}>(entity: {
+    new (): Entity;
+}): BaseFirestoreQuery<Entity>;
+
+type ColParam$1<T extends {
+    readonly collectionPath: string;
+}> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
+interface EntityData {
+    id: string;
+    value: string;
+    collectionPath: string;
+    updatedAt: string;
+}
+declare class DexieAdapter<E extends {
+    id: string;
+    updatedAt: dayjs__default.Dayjs;
+}> extends Dexie {
+    entities: Dexie.Table<EntityData, string>;
+    constructor();
+    count$(): Observable<number>;
+    getLastUpdatedAt$(collectionPath: string): Observable<dayjs__default.Dayjs>;
+    bulkPut(collectionPath: string, entities: E[]): Promise<string>;
+    listChanges(collectionPath: string): Observable<E[]>;
+}
+declare class FirestoreIndexedDbCached<E extends {
+    id: string;
+    updatedAt: dayjs__default.Dayjs;
+}> {
+    protected collectionPath: string;
+    constructor(collectionPath: string);
+    readonly adapter: DexieAdapter<E>;
+    getLastUpdatedAt$(): Observable<dayjs__default.Dayjs>;
+    setMany(entities: E[]): Promise<string>;
+    listChanges(): Observable<E[]>;
+}
+declare abstract class CachedFirestoreQuery<E extends {
+    id: string;
+    updatedAt: dayjs__default.Dayjs;
+} = any> extends FirestoreQuery<E> {
+    protected _cached: FirestoreIndexedDbCached<E>;
+    protected get cached(): FirestoreIndexedDbCached<E>;
+    protected readonly config: {
+        throttleTime: number;
+        loadChunkSize: number;
+    };
+    listChanges(paramMap?: ColParam$1<this>): Observable<E[]>;
+    protected _listChange(paramMap?: ColParam$1<this>): Observable<E[]>;
+    protected _listChangesAfter(collection: CollectionLike, updatedAt: dayjs__default.Dayjs, { limit }?: {
+        limit?: number;
+    }): Observable<E[]>;
+    progressChanges(): Observable<{
+        cloud: number;
+        local: number;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CachedFirestoreQuery<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CachedFirestoreQuery<any>>;
+}
+
+type ExtractEntity<T extends BaseFirestoreRepository<any, any>> = T extends BaseFirestoreRepository<infer Entity, any> ? Entity : never;
+type ColParam<T extends BaseFirestoreRepository<any, any>> = Omit<ExtractParams<T['collectionPath']>, 'id'>;
+type DocParam<T extends BaseFirestoreRepository<any, any>, TExtra = {}> = ColParam<T> & {
+    id: string;
+} & TExtra;
+declare abstract class BaseFirestoreRepository<Entity extends {
+    id: string;
+}, TExtraParams = {}> extends Repository<Entity> {
+    abstract readonly collectionPath: string;
+    protected abstract readonly adapter: FirestoreAdapter;
+    protected abstract converter: IFirestoreConverter<Entity>;
+    abstract readonly pathBuilder: FirestorePathBuilder<Entity, typeof this.collectionPath>;
+    list(paramMap?: ColParam<this>, query?: any): Promise<Entity[]>;
+    listChanges(): Observable<Entity[]>;
+    count(paramMap?: ColParam<this>): Promise<number>;
+    get(paramMap?: DocParam<this, TExtraParams>): Promise<Entity>;
+    save(entity: DocParam<this, TExtraParams> & Entity): Promise<[Entity, boolean]>;
+    saveMany(entities: Entity[]): Promise<void>;
+    create(entity: DocParam<this, TExtraParams> & Entity): Promise<Entity>;
+    createMany(entities: (DocParam<this, TExtraParams> & Entity)[]): Promise<Entity[]>;
+    update(entity: DocParam<this, TExtraParams> & Partial<Entity>): Promise<void>;
+    updateMany(data: Partial<Entity>[]): Promise<void>;
+    delete(paramMap: DocParam<this, TExtraParams>): Promise<void>;
+    deleteMany(params: {
+        id: string;
+    }[]): Promise<number>;
+    deleteAll(): Promise<void>;
+    bulkWrite(entities: (DocParam<this, TExtraParams> & Entity)[], timestamps?: string[]): Promise<void>;
+    bulkCreate(entities: (DocParam<this, TExtraParams> & Entity)[]): Promise<void>;
+    bulkUpdate(entities: (DocParam<this, TExtraParams> & Partial<Entity>)[]): Promise<void>;
+    bulkDelete(paramMaps: DocParam<this, TExtraParams>[]): Promise<void>;
+    protected collection(paramMap?: Omit<ExtractParams<typeof this.collectionPath>, 'id'>): CollectionReference<object>;
+    protected collectionGroup(): CollectionGroup<object>;
+    protected doc(paramMap: DocParam<this, TExtraParams>): DocumentReference<object>;
+    protected genId: () => string;
+    protected _list(collection: CollectionReference<object>): Promise<Entity[]>;
+    protected _get(doc: DocumentReference<object>): Promise<Entity>;
+    protected _save(doc: DocumentReference<object>, entity: Entity): Promise<[Entity, boolean]>;
+    protected _create(doc: DocumentReference<object>, entity: Entity): Promise<Entity>;
+    protected _set(doc: DocumentReference<object>, entity: Partial<Entity>, isUpdate?: boolean): Promise<DocumentSnapshot<object, DocumentData>>;
+    protected buildServerTimestampObject(keys?: string[]): {};
+}
+declare abstract class FirestoreRepository<Entity extends {
+    id: string;
+}, TExtraParams = {}> extends BaseFirestoreRepository<Entity, TExtraParams> {
+    protected readonly adapter: FirestoreAdapter<any>;
+    get pathBuilder(): FirestorePathBuilder<Entity, typeof this.collectionPath>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreRepository<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreRepository<any, any>>;
+}
+declare function getFirestoreRepository<Entity extends {
+    id: string;
+}, TExtraParams = {}>(entity: {
+    new (): Entity;
+}, adapter?: FirestoreAdapter): BaseFirestoreRepository<Entity, TExtraParams>;
+declare function injectFirestoreRepository<Entity extends {
+    id: string;
+}, TExtraParams = {}>(entity: {
+    new (): Entity;
+}): BaseFirestoreRepository<Entity, TExtraParams>;
+
+export { BaseFirestoreQuery, BaseFirestoreRepository, CachedFirestoreQuery, FIRESTORE_ANNOTATIONS, Firestore, FirestoreAdapter, FirestoreDAO, FirestorePathBuilder, FirestoreQuery$1 as FirestoreQuery, FirestoreQuery as FirestoreQueryV2, FirestoreRepository, createClassDecorator, createDecorator, createPropsDecorator, getAnnotations, getCollection, getConverter, getFirestoreAnnotations, getFirestoreQuery, getFirestoreRepository, injectConverter, injectFirestoreQuery, injectFirestoreRepository, parsePath, pathBuilderFactory, provideFirestoreAdapter, resolvePaths };
+export type { ColParam$3 as ColParam, CollectionGroup, CollectionLike, CollectionReference, DocParam$2 as DocParam, DocumentChangeAction, DocumentData, DocumentReference, DocumentSnapshot, ExtractEntity, ExtractParams, FieldValue, FirestoreAnnotation, FirestoreFieldType, GetOptions, IFirestoreConverter, Query, QueryFn, QuerySnapshot, Timestamp, TimestampConstructor, ToFirestoreData, WhereFilterOp };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx-ddd/firestore",
-  "version": "19.2.1",
+  "version": "19.3.1",
   "main": "./index.js",
   "types": "./index.d.ts",
   "homepage": "https://github.com/xx-machina/plaform/tree/main/packages/@nx-ddd/firestore",
@@ -9,10 +9,30 @@
     "url": "https://github.com/xx-machina/plaform.git"
   },
   "peerDependencies": {
-    "@nx-ddd/common": "19.2.1",
-    "@nx-ddd/core": "19.2.1"
+    "@nx-ddd/common": "19.3.1",
+    "@nx-ddd/core": "19.3.1"
   },
-  "dependencies": {},
-  "module": "./index.js",
-  "type": "module"
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/nx-ddd-firestore.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/nx-ddd-firestore.mjs"
+    },
+    "./adapters/admin": {
+      "types": "./adapters/admin/index.d.ts",
+      "default": "./fesm2022/nx-ddd-firestore-adapters-admin.mjs"
+    },
+    "./adapters/firebase": {
+      "types": "./adapters/firebase/index.d.ts",
+      "default": "./fesm2022/nx-ddd-firestore-adapters-firebase.mjs"
+    }
+  },
+  "sideEffects": false
 }

package/README.md

@@ -1,172 +0,0 @@
-# @nx-ddd/firestore
-
-A Firestore adapter for @nx-ddd/core that provides seamless integration with Firebase Cloud Firestore.
-
-## Installation
-
-```bash
-npm install @nx-ddd/firestore
-```
-
-## Features
-
-### 1. Repository Implementation
-
-```typescript
-import { FirestoreRepository } from '@nx-ddd/firestore';
-
-@Injectable()
-export class UserFirestoreRepository extends FirestoreRepository<User> implements UserRepository {
-  constructor(firestore: Firestore) {
-    super(firestore, 'users');
-  }
-
-  async findByEmail(email: string): Promise<User | null> {
-    const snapshot = await this.collection
-      .where('email', '==', email)
-      .limit(1)
-      .get();
-
-    return this.toEntity(snapshot.docs[0]);
-  }
-}
-```
-
-### 2. Entity Mapping
-
-```typescript
-import { FirestoreEntity } from '@nx-ddd/firestore';
-
-@FirestoreEntity({
-  collection: 'users',
-  converters: {
-    createdAt: FirestoreTimestampConverter,
-    updatedAt: FirestoreTimestampConverter
-  }
-})
-export class User extends Entity {
-  constructor(
-    id: ID,
-    public readonly email: string,
-    public readonly name: string,
-    public readonly createdAt: Date,
-    public readonly updatedAt: Date
-  ) {
-    super(id);
-  }
-}
-```
-
-### 3. Transaction Support
-
-```typescript
-import { FirestoreTransactional } from '@nx-ddd/firestore';
-
-@Injectable()
-export class UserService {
-  constructor(private readonly firestore: Firestore) {}
-
-  @FirestoreTransactional()
-  async createUserWithProfile(data: UserData): Promise<void> {
-    const user = new User(/* ... */);
-    const profile = new Profile(/* ... */);
-
-    await this.userRepository.save(user);
-    await this.profileRepository.save(profile);
-  }
-}
-```
-
-### 4. Query Building
-
-```typescript
-import { FirestoreQueryBuilder } from '@nx-ddd/firestore';
-
-@Injectable()
-export class UserQueryService {
-  constructor(private readonly builder: FirestoreQueryBuilder) {}
-
-  async findActiveUsers(): Promise<User[]> {
-    return this.builder
-      .collection('users')
-      .where('status', '==', 'active')
-      .orderBy('lastLoginAt', 'desc')
-      .limit(10)
-      .execute();
-  }
-}
-```
-
-## Advanced Features
-
-### 1. Batch Operations
-
-```typescript
-import { FirestoreBatch } from '@nx-ddd/firestore';
-
-@Injectable()
-export class UserBatchService {
-  constructor(private readonly batch: FirestoreBatch) {}
-
-  async deactivateUsers(userIds: string[]): Promise<void> {
-    this.batch.begin();
-
-    for (const id of userIds) {
-      this.batch.update(`users/${id}`, { status: 'inactive' });
-    }
-
-    await this.batch.commit();
-  }
-}
-```
-
-### 2. Real-time Updates
-
-```typescript
-import { FirestoreObservable } from '@nx-ddd/firestore';
-
-@Injectable()
-export class UserStreamService {
-  constructor(private readonly observable: FirestoreObservable) {}
-
-  watchUserChanges(userId: string): Observable<User> {
-    return this.observable
-      .document(`users/${userId}`)
-      .valueChanges()
-      .pipe(
-        map(data => new User(data))
-      );
-  }
-}
-```
-
-### 3. Sub-collections
-
-```typescript
-import { FirestoreSubCollection } from '@nx-ddd/firestore';
-
-@Injectable()
-export class UserDocumentRepository extends FirestoreRepository<UserDocument> {
-  constructor(firestore: Firestore) {
-    super(firestore, 'users/:userId/documents');
-  }
-
-  async findUserDocuments(userId: string): Promise<UserDocument[]> {
-    return this.find({ userId });
-  }
-}
-```
-
-## Best Practices
-
-1. Use repository pattern for data access
-2. Implement proper error handling
-3. Use transactions for atomic operations
-4. Leverage batch operations for bulk updates
-5. Consider real-time updates when appropriate
-6. Structure collections and sub-collections carefully
-7. Implement proper security rules
-
-## License
-
-MIT