[JS] Firebaseの覚書 ⑦ Firestoreの操作まとめ

import { getApp, FirebaseApp } from 'firebase/app'
import { getFirestore, collection, getDocs, Firestore } from 'firebase/firestore';

const app: FirebaseApp = getApp()
const db: Firestore = getFirestore(app);

async function getCities(db) {
  const citiesCol = collection(db, 'cities');
  const citySnapshot = await getDocs(citiesCol);
  const cityList = citySnapshot.docs.map(doc => doc.data());
  return cityList;
}

// プロパティ
{
  firestore: Firestore,
  id: string,
  parent: DocumentReference.<DocumentData> | null,
  path: string
}

// プロパティ
{
  firestore: Firestore,
  id: string,
  parent: CollectionReference,
  path: string
}

// プロパティ
{
  docs: Array.<QueryDocumentSnapshot>,
  empty: boolean,
  size: number,
  query: Query,
  metadata: SnapshotMetadata
}

{
  exists: boolean,
  id: string,
  metadata: SnapshotMetadata,
  ref: DocumentReference
}

// プロパティ
{
  exists: boolean,
  id: string,
  metadata: SnapshotMetadata,
  ref: DocumentReference
}

import { getApp, FirebaseApp } from 'firebase/app'
import { getFirestore, collection, doc } from 'firebase/firestore';

const app: FirebaseApp = getApp()
const db = getFirestore(app);

// ドキュメント指定
const documentReference = doc(db, `posts/${id}`)

// コレクション指定
const collectionReference = collection(db, 'posts')

// ドキュメント指定
const documentReference = firestore.doc(`posts/${id}`);

// コレクション指定
const collectionReference = firestore.collection('posts');

const data = {
  title: 'サンプルのタイトル',
  content: 'これが本文です'
};

// V9: ドキュメントに保存
import { doc, setDoc } from 'firebase/firestore';

const documentReference = doc(db, 'posts')
await setDoc(documentReference, data)

// V8: ドキュメントに保存
const documentReference = firestore.doc(`posts/${id}`);
await documentReference.set(data);

// V9: 上書きになる場合に渡したデータのフィールドだけ更新する
await setDoc(documentReference, data, { merge: true })

// V8: 上書きになる場合に渡したデータのフィールドだけ更新する
await documentReference.set(data, { merge: true });

// V9: 
import { addDoc } from 'firebase/firestore';
const collectionReference = collection(db, 'posts')
await addDoc(collectionReference, data)

// V8: 自動IDで作成して保存
const collectionReference = firestore.collection('posts');
const reference = await collectionReference.add(data);

// V9:
import { doc, deleteDoc } from "firebase/firestore";
await deleteDoc(doc(db, "posts", postId));

// V8:
await documentReference.delete();

// V9
const snapshot = await getDoc(doc(db, `posts/${id}`));

// V8
const snapshot = await documentReference.get();

// 存在しない
if (!snapshot.exists) return;

// ドキュメントのID
const id = snapshot.id;

// ドキュメントのReference
const ref = snapshot.ref;

// データ全部取得
const data = snapshot.data();

// フィールド指定して取得
const name = snapshot.get('title');

// 更新
await reference.update(data);

{
    name: 'Frank',
    favorites: { food: 'Pizza', color: 'Blue', subject: 'recess' },
    age: 12
}

await reference.update({
  'age': 13,
   'favorites.color: 'Red'
})

const data = {
  oldField: firestore.FieldValue.delete()
}

await reference.update(data);

const docData = {
    stringExample: "Hello world!",
    booleanExample: true,
    numberExample: 3.14159265,
    dateExample: firebase.firestore.Timestamp.fromDate(new Date("December 10, 1815")),
    arrayExample: [5, true, "hello"],
    nullExample: null,
    objectExample: {
        a: 5,
        b: {
            nested: "foo"
        }
    },
    geopointExample: new firebase.firestore.GeoPoint(35.6693094, 139.7013494)
};

{
  createdDate: firebase.firestore.FieldValue.serverTimestamp()
}

{
   count: firestore.FieldValue.increment(1)
}

{
  tags: firestore.FieldValue.arrayUnion(firestore.doc('tags/1'))
}

{
  tags: firestore.FieldValue.arrayRemove(firestore.doc('tags/1'))
}

const query = firestore.collection('posts')
                       .where('published', '==', true)
                       .orderBy('createdDate', 'desc');
const querySnapshot = await query.get();

const posts = querySnapshot.docs.map(doc => {
   return doc.data();
});

const querySnapshot = await firestore.collection('posts')
                               .where('deleted', '==', true)
                               .orderBy('createdDate', 'desc')
                               .get();

QuerySnapshot(posts) {
  docs: [
     QueryDocumentSnapshot(post) {
        ref: DocumentReference // ← これにdelete()
     },
     QueryDocumentSnapshot(post) {
        ref: DocumentReference
     }
  ]
}

// やりがちだけどダメな例
querySnapshot.docs.forEach(async doc => {
 await doc.ref.delete();
});

await Promise.all(
  querySnapshot.docs.map(doc => doc.ref.delete())
);

const query = firestore.collection('posts')
                       .orderBy('createdDate', 'desc');

// 登録
const unsubscribe = query.onSnapshot(onNext, ?onError, ?onCompletion);

// 解除
unsubscribe（）;

.onSnapshot(querySnapshot => {
  querySnapshot.docChanges().forEach(docChange => {
　　　if (docChange.type === 'added') {
       // 追加された
     }
     if (docChange.type === 'modified') {
       // 変更があった
     }
     if (docChange.type === 'removed') {
       // 削除された
     }
  });
})

const posts = [];

// 新着
const unsubscribe = firestore.collection('posts')
  .where('deleted', '==', false)
  .where('publish', '==', true)
  .where('createdDate', '>=', new Date())
  .orderBy('createdDate', 'asc')
  .onSnapshot(querySnapshot => {
     querySnapshot.docChanges().forEach(docChange => {
      const data = change.doc.data();
　　　 if (docChange.type === 'added') {
        posts.unshift(data);
      }
    });
  });

// 更新・削除
const unsubscribe2 = firestore.collection('posts')
  .where('deleted', '==', false)
  .where('publish', '==', true)
  .orderBy('createdDate', 'desc')
  .onSnapshot(querySnapshot => {
     querySnapshot.docChanges().forEach(docChange => {
      const data = change.doc.data();

      if (docChange.type === 'modified') {
        const index = posts.findIndex(
          post => post.id === data.id
        );
        if (index !== -1) {
          posts.splice(index, 1, data);
        }
      }

      if (docChange.type === 'removed') {
        posts = posts.filter(post => post.id !== data.id);
      }
    });
  });

// 最初の20件取得
const querySnapshot = await firestore.collection('posts')
    .orderBy('createdDate', 'desc')
    .limit(20)
    .get();

// ページ処理用に最後のドキュメントを保持
// @type {QueryDocumentSnapshot}
const lastSnapshot = querySnapshot.docs[querySnapshot.docs.length - 1];

// 次の20件
const nextQuerySnapshot = await firestore.collection('posts')
    .orderBy('createdDate', 'desc')
    .startAfter(lastSnapshot)
    .limit(20)
    .get();

if (nextQuerySnapshot.docs.length === 0) return; // ドキュメントない
if (nextQuerySnapshot.docs.length > limit) return; // 表示件数より少ない

async function getPosts(cursorSnapshot) {
  let query;

  if (cursorSnapshot) {
    query = firestore.collection('posts')
      .orderBy('createdDate', 'desc')
      .startAfter(cursorSnapshot)
      .limit(20);
  } else {
    query = firestore.collection('posts')
      .orderBy('createdDate', 'desc')
      .limit(20);
  }
 
  const querySnapshot = await query.get();
  const count = querySnapshot.docs.length;
  let lastSnapshot = null;

  if (count === 0) {
   return { query, count, posts: [], lastSnapshot };
  }

  lastSnapshot = querySnapshot.docs[count - 1];
  
  const posts = querySnapshot.docs.map(doc => {
    return doc.data();
  });
  return { query, count, posts, lastSnapshot };
}

// @type {Array.<Function>}
const unsubscribes = [];

// 最初の読み込み
const init = await getPosts();
unsubscribes.push(init.query.onSnapshot(querySnapshot => { }));

// 次の読み込み
const next = await getPosts(init.lastSnapshot);
unsubscribes.push(next.query.onSnapshot(querySnapshot => { }));

// 解除
unsubscribes.forEach(unsubscribe => unsubscribe());

const querySnapshot = await firestore
  .collection('transactions')
  .orderBy('count', 'desc')
  .get();

await firestore.runTransaction(async transaction => {
  /**
   * 先にgetしなければならない
   * @type {Array.<DocumentSnapshot>} snapshots
   */
  const snapshots = await Promise.all(
    querySnapshot.docs.map(doc => transaction.get(doc.ref))
  );

  // カウントの更新する
  await Promise.all(
    snapshots.map(snapshot =>
      transaction.update(snapshot.ref, {
        count: snapshot.get('count') + 1
      })
    )
  );
});

const querySnapshot = await firestore.collection('posts')
                               .where('deleted', '==', true)
                               .orderBy('createdDate', 'desc')
                               .get();
/**
 * @type {WriteBatch}
 */
const batch = firestore.batch();

querySnapshot.docs.forEach(doc => {
  batch.delete(doc.ref);
});

await batch.commit();

import { getApp, FirebaseApp } from 'firebase/app';
import {
  getFirestore,
  collection,
  writeBatch,
  doc,
  serverTimestamp,
} from 'firebase/firestore';

const data = [
   { id: 1, name: 'Sample 1' },
   { id: 2, name: 'Sample 2'},
   { id: 3, name: 'Sample 3'}
]
const app: FirebaseApp = getApp();
const db = getFirestore(app);
const batch = writeBatch(db);

data.forEach(dat => {
  const ref = doc(collection(db, 'posts'))
   batch.set(ref, {
       ...dat,
        updatedAt: serverTimestamp(),
        createdAt: serverTimestamp(),  // サーバー時間
   });
})

await batch.commit();