@nx-ddd/firestore 19.2.0 → 19.3.0

package/fesm2022/nx-ddd-firestore.mjs

@@ -0,0 +1,796 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject } from '@angular/core';
+import { makeDecoratorFactories, walkObj, plainToInstanceWithValid } from '@nx-ddd/core';
+import { get } from 'lodash-es';
+import dayjs from 'dayjs';
+import { ReplaySubject, throwError, of, lastValueFrom, map as map$1, take as take$1, switchMap as switchMap$1, catchError as catchError$1, NEVER, tap as tap$1, Observable, distinctUntilChanged as distinctUntilChanged$1, retry, throttleTime, combineLatest } from 'rxjs';
+import { switchMap, catchError, shareReplay, tap, map, distinctUntilChanged, take } from 'rxjs/operators';
+import Dexie, { liveQuery } from 'dexie';
+import { Repository } from '@nx-ddd/common/domain';
+import { generateId, toObject } from '@nx-ddd/common';
+
+const FIRESTORE_ANNOTATIONS = 'firestore_annotations';
+const { createDecorator, createPropsDecorator, createClassDecorator, getAnnotations, } = makeDecoratorFactories((type, fieldName, propName, options) => ({ type, fieldName, propName, childType: options.childType }), FIRESTORE_ANNOTATIONS);
+/** @deprecated use getAnnotations */
+function getFirestoreAnnotations(target) {
+    return getAnnotations(target);
+}
+const ID = createDecorator('id');
+const String$1 = createDecorator('string');
+const Null = createDecorator('null');
+const Geopoint = createDecorator('geopoint');
+const Boolean$1 = createDecorator('boolean');
+const Timestamp = createDecorator('timestamp');
+const Number$1 = createDecorator('number');
+const Map$1 = (childType, props) => createDecorator('map', { childType })(props);
+const Array$1 = (childType, props) => createDecorator('array', { childType })(props);
+const Reference = createDecorator('reference');
+function getCollection(target) {
+    const annotations = getAnnotations(target);
+    const annotation = annotations.find((annotation) => annotation.type === 'collection');
+    return annotation.name;
+}
+const Firestore = {
+    Collection: createClassDecorator('collection'),
+    ID: ID,
+    String: String$1,
+    Null: Null,
+    Geopoint: Geopoint,
+    Boolean: Boolean$1,
+    Timestamp: Timestamp,
+    Number: Number$1,
+    Map: Map$1,
+    Array: Array$1,
+    Reference: Reference,
+};
+
+class DateAdapter {
+    isDate(value) {
+        return value instanceof Date || dayjs.isDayjs(value);
+    }
+    isValid(value) {
+        return this.isDate(value) && !isNaN(value.getTime());
+    }
+    getJsDate(value) {
+        return value;
+    }
+    convertToDate(value) {
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DateAdapter, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DateAdapter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class DayjsAdapter {
+    constructor(dateAdapter) {
+        this.dateAdapter = dateAdapter;
+    }
+    isDayjs(value) {
+        return dayjs.isDayjs(value);
+    }
+    isValid(value) {
+        return this.isDayjs(value) && value.isValid();
+    }
+    getJsDate(value) {
+        return value.toDate();
+    }
+    convertToDayjs(value) {
+        return dayjs(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DayjsAdapter, deps: [{ token: DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DayjsAdapter, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DayjsAdapter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: DateAdapter }] });
+
+class FirestoreAdapter {
+    constructor() {
+        this.dateAdapter = inject(DateAdapter);
+    }
+    //** @deprecated */
+    toFirestoreData(entity) {
+        return Object.entries(entity).reduce((pre, [k, v]) => ({
+            ...pre, [k]: this.dateAdapter.isDate(v) ? this.convertDateToTimestamp(v) : v,
+        }), {});
+    }
+    //** @deprecated */
+    fromFirestoreData(data) {
+        return Object.entries(data).reduce((pre, [k, v]) => ({
+            ...pre, [k]: this.isTimestamp(v) ? this.convertTimestampToDate(v) : v,
+        }), {});
+    }
+    toFirestore(obj, Entity) {
+        const newObj = {};
+        for (const annotation of getFirestoreAnnotations(Entity)) {
+            const _value = get(obj, annotation.propName);
+            if (_value === null) {
+                newObj[annotation.fieldName] = null;
+                continue;
+            }
+            switch (annotation.type) {
+                case 'id':
+                case 'string':
+                case 'number':
+                case 'boolean': {
+                    if (typeof _value === 'undefined')
+                        break;
+                    newObj[annotation.fieldName] = _value;
+                    break;
+                }
+                case 'timestamp': {
+                    if (typeof _value === 'undefined')
+                        break;
+                    if (!this.dateAdapter.isDate(_value)) {
+                        console.error('[FirestoreAdapter] _value:', _value);
+                        throw new Error(`Invalid Date Type: ${_value}`);
+                    }
+                    newObj[annotation.fieldName] = this.convertDateToTimestamp(_value);
+                    break;
+                }
+                case 'array': {
+                    if (typeof annotation?.childType === 'undefined') {
+                        if (_value)
+                            newObj[annotation.fieldName] = _value;
+                    }
+                    else {
+                        const Type = annotation.childType();
+                        if (typeof _value === 'undefined')
+                            break;
+                        if (!Array.isArray(_value)) {
+                            newObj[annotation.fieldName] = [];
+                            break;
+                        }
+                        const value = (_value ?? []).map(v => {
+                            switch (Type) {
+                                case String:
+                                case Number:
+                                    return v;
+                                default:
+                                    return this.toFirestore(v, Type);
+                            }
+                        });
+                        if (value)
+                            newObj[annotation.fieldName] = value;
+                    }
+                    break;
+                }
+                case 'map': {
+                    if (typeof _value === 'undefined')
+                        break;
+                    if (typeof annotation?.childType === 'undefined') {
+                        if (_value)
+                            newObj[annotation.fieldName] = _value;
+                    }
+                    else {
+                        const Type = annotation.childType();
+                        const value = this.toFirestore(_value, Type);
+                        if (value)
+                            newObj[annotation.fieldName] = value;
+                    }
+                    break;
+                }
+            }
+        }
+        return newObj;
+    }
+    fromFirestore(data, Entity) {
+        const newObj = {};
+        for (const annotation of getFirestoreAnnotations(Entity)) {
+            const _value = data[annotation.fieldName];
+            if (typeof _value === 'undefined')
+                continue;
+            if (_value === null) {
+                newObj[annotation.propName] = null;
+                continue;
+            }
+            switch (annotation.type) {
+                case 'id':
+                case 'string':
+                case 'number':
+                case 'boolean': {
+                    newObj[annotation.propName] = _value;
+                    break;
+                }
+                case 'timestamp': {
+                    try {
+                        newObj[annotation.propName] = this.convertTimestampToDate(_value);
+                    }
+                    catch (e) {
+                        newObj[annotation.propName] = _value;
+                    }
+                    break;
+                }
+                case 'array': {
+                    if (typeof annotation?.childType === 'undefined') {
+                        newObj[annotation.propName] = _value;
+                    }
+                    else {
+                        const Type = annotation.childType();
+                        const value = _value.map(v => {
+                            switch (Type) {
+                                case String:
+                                case Number:
+                                    return v;
+                                default:
+                                    return this.fromFirestore(v, Type);
+                            }
+                        });
+                        if (value)
+                            newObj[annotation.propName] = value;
+                    }
+                    break;
+                }
+                case 'map': {
+                    if (typeof annotation?.childType === 'undefined') {
+                        newObj[annotation.propName] = _value;
+                    }
+                    else {
+                        const Type = annotation.childType();
+                        const value = this.fromFirestore(_value, Type);
+                        if (value)
+                            newObj[annotation.propName] = value;
+                    }
+                    break;
+                }
+            }
+        }
+        return newObj;
+    }
+    /**
+     * @description FirestoreのUpdateは通常のオブジェクトでは孫以下のプロパティが既存データとマージされないので、パスに変換する必要がある。
+     */
+    flattenForUpdate(obj) {
+        const newObj = {};
+        walkObj(obj, {
+            callback: (paths, value) => newObj[paths.join('.')] = value,
+            overwrite: (_, value) => {
+                if (Array.isArray(value))
+                    return [true, value];
+                if (this.isTimestamp(value))
+                    return [true, value];
+                if (this.isFieldValue(value))
+                    return [true, value];
+                return [false];
+            }
+        });
+        return newObj;
+    }
+    convertDateToTimestamp(date) {
+        return this.Timestamp.fromDate(date);
+    }
+    convertTimestampToDate(timestamp) {
+        return this.dateAdapter.convertToDate(timestamp.toDate());
+    }
+}
+function provideFirestoreAdapter(useClass) {
+    return { provide: FirestoreAdapter, useClass };
+}
+
+class FirestoreHelper {
+    static fromFirestore(doc, Entity, adapter) {
+        const data = adapter.fromFirestore({ ...doc.data(), id: doc.id }, Entity);
+        return plainToInstanceWithValid(Entity, data);
+    }
+}
+class BasicConverter {
+    constructor(Entity, adapter) {
+        this.Entity = Entity;
+        this.adapter = adapter;
+    }
+    fromFirestore(doc) {
+        return this.adapter.fromFirestore({
+            ...doc.data(),
+            id: doc.id
+        }, this.Entity);
+    }
+    fromFirestoreMany(docs) {
+        return docs.map(doc => this.fromFirestore(doc));
+    }
+    toFirestore(entity) {
+        return this.adapter.toFirestore(entity, this.Entity);
+    }
+}
+function getConverter(Entity, adapter = inject(FirestoreAdapter)) {
+    return new BasicConverter(Entity, adapter);
+}
+function injectConverter(Entity) {
+    return getConverter(Entity, inject(FirestoreAdapter));
+}
+
+class FirestoreDAO {
+    constructor(adapter, pathBuilder) {
+        this.adapter = adapter;
+        this.pathBuilder = pathBuilder;
+    }
+    collection(paramMap) {
+        const path = this.pathBuilder.collection(paramMap);
+        return this.adapter.collection(path);
+    }
+    collectionGroup() {
+        const path = this.pathBuilder.collectionGroup();
+        return this.adapter.collectionGroup(path);
+    }
+    doc(paramMap) {
+        const path = this.pathBuilder.doc(paramMap);
+        return this.adapter.doc(path);
+    }
+    getCollection(paramMap) {
+        return paramMap ? this.collection(paramMap) : this.collectionGroup();
+    }
+}
+
+class FirestorePathBuilder {
+    doc(param) {
+        return resolvePaths(param, this.paths);
+    }
+    collection(param = {}) {
+        return resolvePaths(param, this.paths.slice(0, -1));
+    }
+    collectionGroup() {
+        return this.paths[this.paths.length - 2];
+    }
+    constructor(paths) {
+        this.paths = paths;
+    }
+}
+function pathBuilderFactory(path) {
+    const paths = parsePath(path);
+    return new FirestorePathBuilder(paths);
+}
+function parsePath(path) {
+    const paths = path.split('/').filter(p => p.length);
+    if (!paths[paths.length - 1].startsWith(':'))
+        paths.push(':id');
+    return paths;
+}
+const resolvePaths = (obj, paths) => {
+    return paths.map((path) => path.startsWith(':') ? resolvePath(obj, path.slice(1)) : path).join('/');
+};
+const resolvePath = (obj, key) => {
+    if (!obj?.[key])
+        throw new Error(`Invalid key is detected in resolving paths, key: \`${key}\`, obj: \`${JSON.stringify(obj)}\``);
+    return obj?.[key];
+};
+
+let FirestoreQuery$1 = class FirestoreQuery extends FirestoreDAO {
+    constructor(adapter, converter, pathBuilder) {
+        super(adapter, pathBuilder);
+        this.converter = converter;
+        this.pathBuilder = pathBuilder;
+        this.collection$ = new ReplaySubject(1);
+        this.list$ = this.collection$.pipe(switchMap((collection) => this.listChangesByCollectionRef(collection).pipe(catchError(error => throwError(() => error)))), shareReplay(1));
+        this.switchCollectionRef();
+    }
+    /** @deprecated */
+    listChanges(paramMap, options = { switch: true }) {
+        return of(paramMap).pipe(tap((paramMap) => options?.switch && this.switchCollectionRef(paramMap)), switchMap(() => this.list$));
+    }
+    listChangesV2(paramMap) {
+        return of(paramMap).pipe(tap((paramMap) => paramMap && this.switchCollectionRef(paramMap)), switchMap(() => this.list$));
+    }
+    listChangesAfter(updatedAt, { limit } = {}) {
+        const entitiesMap = new Map();
+        const _updatedAt = dayjs.isDayjs(updatedAt) ? this.adapter.convertDateToTimestamp(updatedAt) : updatedAt;
+        return this.adapter.query(this.collection(), ...[
+            this.adapter.where('updatedAt', '>', _updatedAt),
+            this.adapter.orderBy('updatedAt', 'asc'),
+            limit ? this.adapter.limit(limit) : undefined,
+        ].filter(Boolean)).stateChanges().pipe(
+        // bufferTime(1_000),
+        // map(zippedActions => zippedActions.flat()),
+        tap(actions => actions.forEach(({ type, payload: { doc } }) => {
+            if (new Set(['added', 'modified']).has(type)) {
+                entitiesMap.set(doc.id, this.converter.fromFirestore(doc));
+            }
+            else if (type === 'removed') {
+                entitiesMap.delete(doc.id);
+            }
+        })), map(() => [...entitiesMap.values()]));
+    }
+    changes({ id }) {
+        if (!id)
+            throw new Error(`Invalid Id. it must be Truthy`);
+        return this.list$.pipe(map(entities => entities.find(entity => entity.id === id)), distinctUntilChanged((pre, cur) => JSON.stringify(pre) === JSON.stringify(cur)));
+    }
+    changesV2(params) {
+        const docRef = this.doc(params);
+        return docRef.stateChanges().pipe(map((doc) => this.converter.fromFirestore(doc)));
+    }
+    get({ id }) {
+        return lastValueFrom(this.list$.pipe(take(1), map(entities => entities.find(entity => entity.id === id))));
+    }
+    list(paramMap) {
+        this.switchCollectionRef(paramMap);
+        return lastValueFrom(this.list$.pipe(take(1)));
+    }
+    listChangesByCollectionRef(collection) {
+        const entitiesMap = new Map();
+        return collection.stateChanges().pipe(tap(actions => actions.forEach(({ type, payload: { doc } }) => {
+            if (new Set(['added', 'modified']).has(type)) {
+                entitiesMap.set(doc.id, this.converter.fromFirestore(doc));
+            }
+            else if (type === 'removed') {
+                entitiesMap.delete(doc.id);
+            }
+        })), map(() => [...entitiesMap.values()]));
+    }
+    switchCollectionRef(paramMap) {
+        const collection = this.getCollection(paramMap);
+        this.switchCollection(collection);
+    }
+    switchCollection(collection) {
+        this.collection$.next(collection);
+    }
+};
+
+class BaseFirestoreQuery {
+    count(paramMap) {
+        return this.dao.getCollection(paramMap).count();
+    }
+    changes(params) {
+        const docRef = this.dao.doc(params);
+        return docRef.stateChanges().pipe(map$1((doc) => this.converter.fromFirestore(doc)));
+    }
+    get(paramMap) {
+        return lastValueFrom(this.changes(paramMap).pipe(take$1(1)));
+    }
+    list(paramMap) {
+        return lastValueFrom(this.listChanges(paramMap).pipe(take$1(1)));
+    }
+    listChanges(paramMap) {
+        return of(paramMap).pipe(map$1((paramMap) => this.dao.getCollection(paramMap)), switchMap$1((collection) => {
+            return this.getListChanges$ByCollectionLike(collection);
+        }));
+    }
+    getChanges$ByDocument(doc) {
+        return doc.stateChanges().pipe(map$1((doc) => this.converter.fromFirestore(doc)), catchError$1((error) => {
+            console.error(error);
+            return NEVER;
+        }));
+    }
+    getListChanges$ByCollectionLike(collection) {
+        const entitiesMap = new Map();
+        return collection.stateChanges().pipe(tap$1(actions => actions.forEach(({ type, payload: { doc } }) => {
+            if (new Set(['added', 'modified']).has(type)) {
+                entitiesMap.set(doc.id, this.converter.fromFirestore(doc));
+            }
+            else if (type === 'removed') {
+                entitiesMap.delete(doc.id);
+            }
+        })), map$1(() => [...entitiesMap.values()]), catchError$1((error) => {
+            console.error(error);
+            return NEVER;
+        }));
+    }
+}
+class FirestoreQuery extends BaseFirestoreQuery {
+    constructor() {
+        super(...arguments);
+        this.adapter = inject(FirestoreAdapter);
+    }
+    get pathBuilder() {
+        return pathBuilderFactory(this.collectionPath);
+    }
+    get dao() {
+        return new FirestoreDAO(this.adapter, this.pathBuilder);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: FirestoreQuery, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: FirestoreQuery }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: FirestoreQuery, decorators: [{
+            type: Injectable
+        }] });
+function getFirestoreQuery(entity, adapter = inject(FirestoreAdapter)) {
+    class FirestoreQuery extends BaseFirestoreQuery {
+        constructor(converter, collectionPath, pathBuilder, adapter, dao) {
+            super();
+            this.converter = converter;
+            this.collectionPath = collectionPath;
+            this.pathBuilder = pathBuilder;
+            this.adapter = adapter;
+            this.dao = dao;
+        }
+    }
+    return new FirestoreQuery(getConverter(entity, adapter), getCollection(entity), pathBuilderFactory(getCollection(entity)), adapter, new FirestoreDAO(adapter, pathBuilderFactory(getCollection(entity))));
+}
+function injectFirestoreQuery(entity) {
+    return getFirestoreQuery(entity, inject(FirestoreAdapter));
+}
+
+function fromDexie(observable) {
+    return new Observable(subscriber => observable.subscribe(subscriber));
+}
+class DexieAdapter extends Dexie {
+    constructor() {
+        super('@nx-ddd/firestore/cached-query');
+        this.version(3).stores({ entities: '++id' });
+    }
+    count$() {
+        return fromDexie(liveQuery(() => this.entities.count()));
+    }
+    getLastUpdatedAt$(collectionPath) {
+        return of(null).pipe(switchMap$1((() => fromDexie(liveQuery(() => this.entities.toArray())))), map$1((entities) => entities.filter(entity => entity.collectionPath === collectionPath)), map$1(entities => entities.sort((a, b) => {
+            if (!a?.updatedAt)
+                return -1;
+            if (!b?.updatedAt)
+                return 1;
+            return dayjs(a?.updatedAt).diff(dayjs(b?.updatedAt));
+        }).at(-1)), map$1(entity => entity?.updatedAt ? dayjs(entity?.updatedAt) : dayjs('1970-01-01')), distinctUntilChanged$1((pre, cur) => pre.isSame(cur)));
+    }
+    async bulkPut(collectionPath, entities) {
+        return this.entities.bulkPut(entities.map(entity => {
+            const key = `${entity.id}`;
+            return {
+                id: key,
+                collectionPath,
+                value: JSON.stringify(entity),
+                updatedAt: entity.updatedAt.toISOString(),
+            };
+        }));
+    }
+    listChanges(collectionPath) {
+        return of(null).pipe(switchMap$1(() => fromDexie(liveQuery(() => this.entities.toArray()))), map$1((entities) => entities.filter(entity => entity.collectionPath === collectionPath)), map$1((entities) => entities.map(entity => JSON.parse(entity.value))));
+    }
+}
+class FirestoreIndexedDbCached {
+    constructor(collectionPath) {
+        this.collectionPath = collectionPath;
+        this.adapter = new DexieAdapter();
+    }
+    getLastUpdatedAt$() {
+        return this.adapter.getLastUpdatedAt$(this.collectionPath);
+    }
+    async setMany(entities) {
+        return this.adapter.bulkPut(this.collectionPath, entities);
+    }
+    listChanges() {
+        return this.adapter.listChanges(this.collectionPath);
+    }
+}
+class CachedFirestoreQuery extends FirestoreQuery {
+    constructor() {
+        super(...arguments);
+        this.config = {
+            throttleTime: 5_000,
+            loadChunkSize: 1_000,
+        };
+    }
+    get cached() {
+        return this._cached ??= new FirestoreIndexedDbCached(this.collectionPath);
+    }
+    listChanges(paramMap) {
+        const collection = this.dao.getCollection(paramMap);
+        return this.cached.getLastUpdatedAt$().pipe(switchMap$1((lastUpdatedAt) => this._listChangesAfter(collection, lastUpdatedAt, {
+            limit: this.config.loadChunkSize,
+        }).pipe(retry(3), tap$1((updated) => this.cached.setMany(updated)), tap$1((updated) => console.log('updated:', updated)), catchError$1((error) => (console.error(error), NEVER)))), switchMap$1(() => this.cached.listChanges()), map$1((entities) => entities.map(entity => this.converter.fromObject(entity))), throttleTime(this.config.throttleTime));
+    }
+    _listChange(paramMap) {
+        return of(paramMap).pipe(map$1((paramMap) => this.dao.getCollection(paramMap)), map$1((collection) => this.adapter.query(collection, this.adapter.limit(10))), switchMap$1((collection) => this.getListChanges$ByCollectionLike(collection)));
+    }
+    _listChangesAfter(collection, updatedAt, { limit } = {}) {
+        const updatedAtTs = dayjs.isDayjs(updatedAt) ? this.adapter.convertDateToTimestamp(updatedAt) : updatedAt;
+        const query = this.adapter.query(collection, ...[
+            this.adapter.where('updatedAt', '>', updatedAtTs),
+            this.adapter.orderBy('updatedAt', 'asc'),
+            limit ? this.adapter.limit(limit) : undefined,
+        ].filter(Boolean));
+        return this.getListChanges$ByCollectionLike(query);
+    }
+    progressChanges() {
+        return combineLatest({
+            cloud: this.count(),
+            local: this.listChanges().pipe(map$1(items => items.length)),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: CachedFirestoreQuery, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: CachedFirestoreQuery }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: CachedFirestoreQuery, decorators: [{
+            type: Injectable
+        }] });
+
+const toPromise = callback => new Promise((resolve, reject) => {
+    try {
+        resolve(callback());
+    }
+    catch (error) {
+        reject(error);
+    }
+});
+function doesExist(doc) {
+    if (typeof doc.exists === 'function') {
+        return doc.exists();
+    }
+    return doc.exists;
+}
+class BaseFirestoreRepository extends Repository {
+    constructor() {
+        super(...arguments);
+        this.genId = () => generateId();
+    }
+    async list(paramMap, query = q => q) {
+        const collection = paramMap ? this.collection(paramMap) : this.collectionGroup();
+        return this._list(query(collection));
+    }
+    listChanges() {
+        throw new Error('Method not implemented.');
+    }
+    async count(paramMap) {
+        return this.collection(paramMap).count();
+    }
+    async get(paramMap) {
+        return this._get(this.doc(paramMap));
+    }
+    async save(entity) {
+        const docRef = this.doc({ ...entity, id: entity?.id || this.genId() });
+        return this._save(docRef, entity);
+    }
+    async saveMany(entities) {
+        return this.bulkWrite(entities);
+    }
+    async create(entity) {
+        const obj = toObject(entity);
+        const id = obj?.id || this.genId();
+        return toPromise(() => this.doc({ ...obj, id })).then(doc => this._create(doc, entity));
+    }
+    async createMany(entities) {
+        return Promise.all(entities.map(entity => this.create(entity)));
+    }
+    async update(entity) {
+        return this.doc(entity).update(this.adapter.flattenForUpdate({
+            ...this.converter.toFirestore(entity),
+            ...this.buildServerTimestampObject(['updatedAt']),
+        })).then(() => { });
+    }
+    async updateMany(data) {
+        return this.bulkUpdate(data);
+    }
+    delete(paramMap) {
+        return this.doc(paramMap).delete();
+    }
+    async deleteMany(params) {
+        return params.reduce((batch, param) => {
+            const doc = this.doc(param).__ref;
+            return batch.delete(doc);
+        }, this.adapter.batch()).commit().then(() => params.length);
+    }
+    async deleteAll() {
+        throw new Error('Method not implemented.');
+    }
+    async bulkWrite(entities, timestamps = []) {
+        return entities.reduce((batch, entity) => {
+            const doc = this.doc(entity).__ref;
+            return batch.set(doc, {
+                ...this.converter.toFirestore(entity),
+                ...this.buildServerTimestampObject(timestamps),
+            });
+        }, this.adapter.batch()).commit();
+    }
+    async bulkCreate(entities) {
+        // TODO(nontangent): add maximum 500 record validation
+        return entities.reduce((batch, entity) => {
+            const doc = this.doc(entity).__ref;
+            return batch.create(doc, {
+                ...this.converter.toFirestore(entity),
+                ...this.buildServerTimestampObject(['createdAt', 'updatedAt']),
+            });
+        }, this.adapter.batch()).commit();
+    }
+    async bulkUpdate(entities) {
+        // TODO(nontangent): add maximum 500 record validation
+        return entities.reduce((batch, entity) => {
+            const doc = this.doc(entity).__ref;
+            return batch.update(doc, {
+                ...this.converter.toFirestore(entity),
+                ...this.buildServerTimestampObject(['updatedAt']),
+            });
+        }, this.adapter.batch()).commit();
+    }
+    async bulkDelete(paramMaps) {
+        // MEMO(@nontangent): 500件以上の削除は未対応
+        return paramMaps.reduce((batch, paramMap) => {
+            const doc = this.doc(paramMap).__ref;
+            return batch.delete(doc);
+        }, this.adapter.batch()).commit();
+    }
+    collection(paramMap) {
+        const path = this.pathBuilder.collection(paramMap);
+        return this.adapter.collection(path);
+    }
+    collectionGroup() {
+        const path = this.pathBuilder.collectionGroup();
+        return this.adapter.collectionGroup(path);
+    }
+    doc(paramMap) {
+        const path = this.pathBuilder.doc(paramMap);
+        return this.adapter.doc(path);
+    }
+    _list(collection) {
+        return collection.get().then(({ docs }) => docs.map(doc => {
+            if (!doesExist(doc))
+                return null;
+            return this.converter.fromFirestore(doc);
+        }));
+    }
+    _get(doc) {
+        return doc.get().then((doc => {
+            if (!doc.data())
+                return null;
+            return this.converter.fromFirestore(doc);
+        }));
+    }
+    async _save(doc, entity) {
+        const exists = await doc.exists();
+        if (exists) {
+            return this._set(doc, entity).then(doc => [this.converter.fromFirestore(doc), false]);
+        }
+        else {
+            return this._create(doc, entity).then(entity => [entity, true]);
+        }
+    }
+    async _create(doc, entity) {
+        const exists = await doc.exists().catch((error) => {
+            // MEMO(@nontangent): bunで実行するときだけこのエラーがでるかもしれない。
+            if (`${error}`.startsWith('Error: Did not receive document for'))
+                return false;
+            throw error;
+        });
+        if (exists)
+            throw new Error('Document already exists');
+        return doc.set({
+            ...this.converter.toFirestore(entity),
+            ...this.buildServerTimestampObject(['createdAt', 'updatedAt']),
+        }).then(() => doc.get()).then(doc => this.converter.fromFirestore(doc));
+    }
+    _set(doc, entity, isUpdate = true) {
+        const data = this.converter.toFirestore(entity);
+        return doc.set({
+            ...this.converter.toFirestore(entity),
+            ...this.buildServerTimestampObject(isUpdate ? ['updatedAt'] : []),
+        }, { merge: isUpdate }).then(() => doc.get());
+    }
+    buildServerTimestampObject(keys = ['createdAt', 'updatedAt']) {
+        return keys.reduce((m, k) => ({ ...m, [k]: this.adapter.FieldValue.serverTimestamp() }), {});
+    }
+}
+class FirestoreRepository extends BaseFirestoreRepository {
+    constructor() {
+        super(...arguments);
+        this.adapter = inject(FirestoreAdapter);
+    }
+    get pathBuilder() {
+        return pathBuilderFactory(this.collectionPath);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: FirestoreRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: FirestoreRepository }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: FirestoreRepository, decorators: [{
+            type: Injectable
+        }] });
+function getFirestoreRepository(entity, adapter = inject(FirestoreAdapter)) {
+    class FirestoreRepository extends BaseFirestoreRepository {
+        constructor(converter, collectionPath, pathBuilder, adapter) {
+            super();
+            this.converter = converter;
+            this.collectionPath = collectionPath;
+            this.pathBuilder = pathBuilder;
+            this.adapter = adapter;
+        }
+    }
+    return new FirestoreRepository(getConverter(entity, adapter), getCollection(entity), pathBuilderFactory(getCollection(entity)), adapter);
+}
+function injectFirestoreRepository(entity) {
+    return getFirestoreRepository(entity, inject(FirestoreAdapter));
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+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 };
+//# sourceMappingURL=nx-ddd-firestore.mjs.map