لنفرض أن تطبيقك يعمل على Firebase منذ ثلاث سنوات، وفيه عشرات الآلاف من المستخدمين سجلوا بالبريد وكلمة المرور، وبياناتهم في Firestore، وصورهم في Cloud Storage، ثم جاء سبب للانتقال: إقامة البيانات Data Residency داخل الدولة، أو فاتورة تكبر كل شهر، أو قرار بأن تكون الخلفية Backend على سيرفرك. والسؤال الأول الذي يسأله الفريق ليس «إلى أين؟»، وإنما «هل سيضطر كل مستخدم إلى تعيين كلمة مرور جديدة؟»، والسبب أن رسالة «أعد تعيين كلمة مرورك» تفقدك نسبة من المستخدمين لا يعودون أبداً. وفي مقال ما هو Backend as a Service؟ ذكرنا أن كلمات المرور طبقة من طبقات الارتباط بالمزود Vendor Lock-in، ووعدنا بتفصيلها، وهذا هو المقال.
والانتقال الذي نقصده هنا هو نقل البيانات والمستخدمين وكلمات المرور والقواعد إلى خلفية مفتوحة المصدر على سيرفرك، وقد اختبرناه كاملاً دون حساب Google ودون مشروع Firebase حقيقي، على محاكي Firebase الرسمي Emulator Suite، ثم استوردنا المستخدمين أنفسهم إلى Supabase وAppwrite وPocketBase. وسوف نناقش في هذا المقال ما يلي:
- ما الذي ينتقل بأدوات جاهزة، وما الذي يحتاج كوداً، وما الذي يعاد بناؤه.
- تشغيل محاكي Firebase محلياً، وماذا يحتوي ملف التصدير، ولماذا لا يكفي وحده.
- كيف يحسب Firebase هاش كلمة المرور بخوارزمية scrypt المعدلة، وما المعاملات التي تحتاجها من مشروعك.
- الاستيراد إلى Supabase بطريقتين، وإلى Appwrite، وإلى PocketBase، والدخول بكلمة المرور القديمة في كل منها.
- بيانات Firestore إلى جداول، وإعادة ربط كل سجل بمالكه بعد أن تغير معرفه.
- قواعد الأمان Security Rules مقابل سياسات RLS والصلاحيات Permissions، في جدول واحد.
- خطة التحويل نفسها، والأخطاء التي رأيناها في المختبر.
ما الذي ينتقل، وما الذي يعاد بناؤه؟
قبل أي أمر، افصل المشروع إلى أجزائه، لأن لكل جزء طريقاً مختلفاً، والصورة التالية تلخص ما وجدناه في المختبر:

| الجزء في Firebase | كيف يخرج | ما يحتاجه في الوجهة |
|---|---|---|
| Authentication | firebase auth:export إلى JSON أو CSV، مع معاملات الهاش Hash من اللوحة | نظام يقبل هاش scrypt المعدل، وإلا فاستعادة كلمة مرور لكل مستخدم |
| Cloud Firestore | قراءة المجموعات عبر Admin SDK وكتابتها JSON | تصميم جداول، وكود للمجموعات الفرعية والمراجع والتواريخ |
| Security Rules | لا تخرج بأي أداة | إعادة كتابتها سياسات أو صلاحيات، ثم اختبارها |
| Cloud Storage | تنزيل الملفات ثم رفعها | مسارات جديدة، وتحديث كل رابط محفوظ في البيانات |
| Cloud Functions | الكود عندك أصلاً | إعادة كتابة المحفزات Triggers بأحداث النظام الجديد |
| Cloud Messaging | لا ينتقل | يبقى، أو يستبدل جزئياً، كما في مقال الإشعارات بدون Firebase |
والترتيب الذي نقترحه هو ترتيب هذا المقال: المستخدمون أولاً، لأنهم يحددون معرفات الملكية في كل شيء آخر، ثم البيانات، ثم القواعد، ثم الملفات، ثم التحويل.
قبل أي أمر: جرد المشروع Inventory
أكثر الانتقالات التي تتعثر لا تتعثر في الأدوات، وإنما في شيء لم يعرف الفريق أنه موجود، فابدأ بجرد مكتوب يجيب عن الأسئلة التالية، وكل سؤال منها غير قراراً في مختبرنا:
- طرق الدخول Sign-in Providers: كم مستخدماً بالبريد وكلمة المرور، وكم بحساب Google أو Apple، وكم برقم الجوال، وكم مستخدماً مجهولاً Anonymous؟ والسبب أن هاش كلمة المرور يخص الفئة الأولى فقط، أما مستخدمو OAuth فلا كلمة مرور لهم أصلاً، ويعيدون الربط عند أول دخول بمزودهم في النظام الجديد، وهذا يحتاج أن تكون معرفات تطبيقك لدى Google وApple مضبوطة في الخلفية الجديدة قبل يوم التحويل.
- المطالبات المخصصة Custom Claims: إذا كان تطبيقك يضع في توكن Token Firebase أدواراً مثل
admin: trueفهذه تخرج مع المستخدم فيcustomAttributes، ومقابلها في Supabase حقلapp_metadataالذي لا يعدله المستخدم، وفي Appwrite الوسوم Labels التي تستخدم في الصلاحيات مباشرة، وفي PocketBase حقل في مجموعة المستخدمين لا تسمح القواعد بتعديله. - حالة البريد والحسابات المعطلة:
emailVerifiedوdisabledيجب أن ينتقلا، والسبب أن نسيانهما يعيد الحساب المعطل إلى العمل، أو يطلب من آلاف المستخدمين تأكيد بريد أكدوه قبل سنوات. - المجموعات الفرعية والمراجع: اكتب لكل نوع مستند مجموعاته الفرعية والحقول التي هي مراجع، فهذه لا تخرج بالأدوات كما سنرى.
- حجم كل مجموعة: عدد المستندات في كل مجموعة قبل الانتقال هو الرقم الذي تقارن به بعده، وبدونه لا تعرف هل نقلت كل شيء.
- من يكتب في Firebase غير التطبيق: دوال سحابية، أو سكربتات إدارية، أو تكامل مع نظام آخر يكتب بمفتاح خدمة، فكل هذه يجب أن تنتقل أو تتوقف قبل التصدير النهائي.
محاكي Firebase دون حساب Google
المحاكي Firebase Local Emulator Suite جزء من أداة firebase-tools الرسمية، ويشغل نسخاً محلية من Auth وFirestore وStorage وFunctions، وأي مشروع يبدأ اسمه ب demo- يعمل دون تسجيل دخول ودون أي اتصال بمشروع حقيقي، كما يذكر المحاكي نفسه عند التشغيل. والمحاكي يحتاج Java، فبنينا له Container صغيراً:
# Firebase Local Emulator Suite without a Google account: Java 21 for the emulators, Node.js for the CLI
FROM debian:13-slim
RUN apt-get update && apt-get install -y --no-install-recommends openjdk-21-jre-headless nodejs npm ca-certificates curl \
&& rm -rf /var/lib/apt/lists/*
RUN npm i -g [email protected] && npm cache clean --force
WORKDIR /workوملف المشروع يشغل المصادقة Authentication وFirestore فقط، ومعه ملف قواعد يشبه ما في تطبيق حقيقي، فيه مهام يملكها المستخدم، ومنتجات للقراءة العامة، وطلبات لها مجموعة فرعية:
{
"firestore": { "rules": "firestore.rules" },
"emulators": {
"auth": { "host": "0.0.0.0", "port": 9099 },
"firestore": { "host": "0.0.0.0", "port": 8080 },
"ui": { "enabled": false },
"singleProjectMode": true
}
}rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
// a user reads and writes only his own todos
match /todos/{todoId} {
allow read, update, delete: if request.auth != null && request.auth.uid == resource.data.owner;
allow create: if request.auth != null && request.auth.uid == request.resource.data.owner
&& request.resource.data.title is string && request.resource.data.title.size() <= 200;
}
// products: anyone reads, nobody writes from the app
match /products/{productId} {
allow read: if true;
allow write: if false;
}
// orders: the buyer reads his orders; items are a subcollection
match /orders/{orderId} {
allow read: if request.auth != null && request.auth.uid == resource.data.uid;
match /items/{itemId} {
allow read: if request.auth != null && request.auth.uid == get(/databases/$(database)/documents/orders/$(orderId)).data.uid;
}
}
}
}docker run -d --name sc5-fbemu -p 127.0.0.1:29099:9099 -p 127.0.0.1:28080:8080 -v "$PWD/project:/work" -w /work \
sc5-firebase-emu:15.37.0 firebase emulators:start --project demo-shop --only auth,firestore
docker logs sc5-fbemuوالمخرج سوف يكون كما يلي، وقد اختصرنا الجدول في آخره:
i emulators: Starting emulators: auth, firestore
i emulators: Detected demo project ID "demo-shop", emulated services will use a demo configuration and attempts to access non-emulated services for this project will fail.
i firestore: downloading cloud-firestore-emulator-v1.22.0.jar...
i firestore: Firestore Emulator logging to firestore-debug.log
✔ firestore: Firestore Emulator was started in standard edition.
┌─────────────────────────────────────────────────────────────┐
│ ✔ All emulators ready! It is now safe to connect your app. │
└─────────────────────────────────────────────────────────────┘ولاحظ أن محاكي Firestore نفسه ملف Java بالإصدار 1.22.0 تنزله الأداة في أول تشغيل، فإذا كان السيرفر بلا إنترنت فانسخه إلى مجلد ~/.cache/firebase/emulators مسبقاً، واستغرق بناء ال Container عندنا أكثر من دقيقتين وحجمه 1.13 جيجابايت بسبب Java.
بيانات مثل بيانات تطبيق حقيقي
ثم ملأنا المحاكي بسكربت يتصرف كتطبيق: مستخدمان يسجلان بمكتبة العميل firebase ويكتبان مهامهما من خلال القواعد نفسها، ثم سكربت إداري بمكتبة firebase-admin يكتب المنتجات وطلباً له مجموعة فرعية من العناصر، وكل عنصر يشير إلى المنتج بمرجع DocumentReference:
const people = [
{ email: '[email protected]', password: 'Sara-Old-Pass-1', todos: ['خطة الإطلاق', 'مراجعة العقود'] },
{ email: '[email protected]', password: 'Omar-Old-Pass-2', todos: ['تجديد النطاق'] },
]
for (const p of people) {
const { user } = await createUserWithEmailAndPassword(auth, p.email, p.password)
for (const t of p.todos) await addDoc(collection(db, 'todos'), { title: t, done: false, owner: user.uid, created: Timestamp.now() })
p.uid = user.uid
console.log('user', p.email, user.uid, 'todos:', p.todos.length)
await signOut(auth)
}
// the rules at work: a signed-out client reading todos is refused
await getDocs(collection(db, 'todos')).catch(e => console.log('anonymous read todos ->', e.code))
// admin side: products with nested maps and arrays, an order with an items subcollection
process.env.FIRESTORE_EMULATOR_HOST = `${HOST}:8080`
const fs = adminFirestore(initAdmin({ projectId: 'demo-shop' }, 'admin'))
await fs.doc('products/p1').set({ name: 'قهوة عربية', price: 45.5, tags: ['coffee', 'gift'], stock: { riyadh: 12, jeddah: 0 } })
await fs.doc('products/p2').set({ name: 'تمر سكري', price: 60, tags: ['dates'], stock: { riyadh: 30, jeddah: 8 } })
const order = await fs.collection('orders').add({ uid: people[0].uid, total: 151, status: 'paid', createdAt: AdminTimestamp.now() })
await order.collection('items').add({ product: fs.doc('products/p1'), qty: 2 })
await order.collection('items').add({ product: fs.doc('products/p2'), qty: 1 })
console.log('admin wrote 2 products and order', order.id, 'with 2 items')user [email protected] NJfHQBbpq3a6cRByUE7zEnEn4j4B todos: 2
user [email protected] Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU todos: 1
anonymous read todos -> permission-denied
admin wrote 2 products and order YB1Dvqy7cBYowEGPwHqS with 2 itemsولاحظ شكل معرف المستخدم NJfHQBbpq3a6cRByUE7zEnEn4j4B، فهو نص من 28 حرفاً وليس UUID، وسوف يهمنا هذا عند الاستيراد. وفي المحاولة الأولى توقف السكربت الإداري بالخطأ admin.firestore is not a function، والسبب أن firebase-admin بالإصدار 14 مع وحدات ES لا يعطي الكائن القديم admin.firestore()، وإنما الدوال من المسارين firebase-admin/app وfirebase-admin/firestore، كما في السكربت أعلاه.
ماذا يوجد في ملف التصدير؟
docker exec -w /work sc5-fbemu firebase emulators:export ./export --project demo-shop --force
find export -type f | xargs ls -la
cat export/auth_export/accounts.json✔ Export complete
-rw-r--r-- 1 wajdy 197609 1080 Nov 20 00:27 export/auth_export/accounts.json
-rw-r--r-- 1 wajdy 197609 99 Nov 20 00:27 export/auth_export/config.json
-rw-r--r-- 1 wajdy 197609 255 Nov 20 00:27 export/firebase-export-metadata.json
-rw-r--r-- 1 wajdy 197609 52 Nov 20 00:27 export/firestore_export/all_namespaces/all_kinds/all_namespaces_all_kinds.export_metadata
-rw-r--r-- 1 wajdy 197609 1600 Nov 20 00:27 export/firestore_export/all_namespaces/all_kinds/output-0
-rw-r--r-- 1 wajdy 197609 95 Nov 20 00:27 export/firestore_export/firestore_export.overall_export_metadata
{"kind":"identitytoolkit#DownloadAccountResponse","users":[{"localId":"Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU","lastLoginAt":"1795123645301","emailVerified":false,"email":"[email protected]","salt":"fakeSaltnqiSt5DSSGArG6dW5b0s","passwordHash":"fakeHash:salt=fakeSaltnqiSt5DSSGArG6dW5b0s:password=Omar-Old-Pass-2", …هنا أول مفاجأتين. الأولى أن المحاكي لا يحسب هاشاً حقيقياً أصلاً، وإنما يحفظ كلمة المرور نصاً واضحاً داخل حقل اسمه fakeHash، وهذا مناسب لمحاك على جهاز المطور، لكنه يعني أن ملف التصدير لا يصلح لتجربة استيراد كلمات المرور كما هو. والثانية أن ملف Firestore المصدر ليس JSON:
head -c 300 export/firestore_export/all_namespaces/all_kinds/output-0 | od -c | head -40000000 363 372 027 3 313 \0 001 j 0 j \r d e v ~ d
0000020 e m o - s h o p r 037 \v 022 005 t o d
0000040 o s " 024 8 x G H K Q G M k K p j
0000060 f N o q d v a D \f z " 032 005 t i tفهو ملف ثنائي بصيغة التصدير المدار نفسها التي يكتبها Firestore الحقيقي في Cloud Storage، وتوثيق التصدير والاستيراد يذكر أنها تستورد في Firestore أو تحمل في BigQuery، وليست صيغة تفتحها قاعدة أخرى. والصورة التالية تجمع الملاحظتين والحل لكل منهما:

من Firestore إلى JSON
لنقل البيانات تنشر Supabase أدوات في مستودع firebase-to-supabase، منها firestore2json.js الذي يقرأ مجموعة كاملة عبر Admin SDK ويكتبها في ملف JSON، وfirestoreusers2json.js الذي يفعل ذلك بالمستخدمين، وكلاهما يعمل مع المحاكي إذا ضبطت المتغيرين FIRESTORE_EMULATOR_HOST وFIREBASE_AUTH_EMULATOR_HOST. والأداتان تقرآن ملف حساب خدمة اسمه firebase-service.json، ومع المحاكي لا يستخدم المفتاح أصلاً، لكن المكتبة تتحقق من شكل الملف، فولدنا ملفاً بمفتاح RSA مؤقت لا يرتبط بأي حساب:
node -e '
const {generateKeyPairSync}=require("crypto");const {privateKey}=generateKeyPairSync("rsa",{modulusLength:2048});
const sa={type:"service_account",project_id:"demo-shop",private_key_id:"lab",private_key:privateKey.export({type:"pkcs8",format:"pem"}),client_email:"[email protected]",client_id:"1",token_uri:"https://oauth2.googleapis.com/token"};
for (const d of ["firestore","auth"]) require("fs").writeFileSync(d+"/firebase-service.json",JSON.stringify(sa,null,1));'
docker run --rm --network sc5-net -e FIRESTORE_EMULATOR_HOST=sc5-fbemu:8080 -e FIREBASE_AUTH_EMULATOR_HOST=sc5-fbemu:9099 \
-v "$PWD/f2s:/f2s" -w /f2s/firestore node:22-alpine \
sh -c 'node collections.js; for c in todos products orders; do node firestore2json.js $c; done; cd ../auth && node firestoreusers2json.js users.json'orders
products
todos
3 records written to todos.json
2 records written to products.json
1 records written to orders.jsonوالملف orders.json فيه ما يلي:
[
{
"uid": "NJfHQBbpq3a6cRByUE7zEnEn4j4B",
"total": 151,
"status": "paid",
"createdAt": {
"_seconds": 1795123646,
"_nanoseconds": 153000000
},
"firestore_id": "YB1Dvqy7cBYowEGPwHqS"
}
]في المخرج أعلاه لاحظ التالي:
- الطلب خرج دون عناصره، فالأداة تقرأ المجموعات في المستوى الأول فقط، والمجموعة الفرعية
itemsغير موجودة في أي ملف، ولو لم نكن نعرف أنها موجودة لضاعت دون أي رسالة. ولذلك اعرض قائمة المجموعات الفرعية لكل نوع من المستندات قبل الانتقال، وانقلها بسكربت، أو بخطاف Hook من النوع الذي يشرحه ملفHOOKS.mdفي المستودع. - التاريخ خرج كائناً فيه
_secondsو_nanosecondsوليس نص تاريخ، فيجب تحويله عند الاستيراد. - الأداة أضافت حقلاً اسمه
firestore_idفيه معرف المستند، وهذا مهم لأن معرف المستند في Firestore ليس حقلاً في بياناته. - المرجع DocumentReference في عنصر الطلب كان سيحتاج تحويلاً إلى معرف نصي أيضاً، فلا يوجد مقابل له في JSON.
من المستند إلى الجدول: قرارات التصميم
الأداة تعطيك ملف JSON، لكن شكل البيانات في Firestore صمم لقاعدة مستندات، ونقله كما هو إلى جدول واحد بأعمدة jsonb يعمل، لكنه يضيع أهم ما تكسبه من الانتقال إلى قاعدة علائقية. فالمستندات في Firestore تكتب عادة مكررة Denormalized بقصد، لأن Firestore لا يملك ربطاً Join بين المجموعات، فتجد اسم المستخدم وصورته منسوخين في كل منشور كتبه، وعدد الإعجابات محفوظاً في المنشور وفي مجموعة أخرى معاً. وعند الانتقال تواجه لكل حقل من هذا النوع سؤالاً واحداً: هل هو نسخة من بيانات موجودة في مكان آخر، أم بيانات أصلية؟ فالنسخة تحذف ويحل محلها ربط، والأصلية تبقى. والقواعد التي اتبعناها في المختبر وننصح بها:
- الخريطة Map التي لها شكل ثابت، مثل مخزون الفروع، جدول مستقل بصف لكل عنصر، والسبب أن الاستعلام عن «كل المنتجات النافدة في جدة» على عمود jsonb أصعب وأبطأ من جدول عادي بفهرس.
- المصفوفة Array من القيم البسيطة، مثل الوسوم، تبقى مصفوفة في PostgreSQL أو تصبح جدولاً إذا كنت ستبحث بها كثيراً.
- المجموعة الفرعية جدول بمفتاح أجنبي Foreign Key إلى الأب، فعناصر الطلب جدول
order_itemsفيهorder_id. - المرجع DocumentReference مفتاح أجنبي إلى الجدول الذي يشير إليه، وهنا يظهر أول خطأ لم يكتشفه أحد في Firestore: المراجع التي تشير إلى مستندات حذفت، فالقيد في PostgreSQL سيرفض إدخالها، وهذا خبر جيد، لكن يجب أن تقرر ماذا تفعل بها قبل الاستيراد.
- معرف المستند يبقى في عمود، ولو جعلت المفتاح الأساسي رقماً متسلسلاً، والسبب أن الروابط المحفوظة في التطبيقات القديمة وفي الإشعارات المرسلة تحمل المعرف القديم.
وتفصيل التطبيع Normalization ومتى تخالف قواعده عن قصد في تصميم قواعد البيانات، والمقارنة بين قاعدة المستندات والقاعدة العلائقية في PostgreSQL أم MySQL أم MongoDB. وإذا كان تطبيقك يستخدم Realtime Database القديمة وليس Firestore، فهي شجرة JSON واحدة كبيرة، وتصدر من لوحة Firebase أو من واجهتها كملف JSON، وهذا أسهل في القراءة من Firestore، لكنه أصعب في التصميم، لأن الشجرة كلها تحتاج أن تفكك إلى جداول، ولاحظ أن أداة Appwrite المدمجة لا تدعمها أصلاً بحسب صفحتها.
كيف يحسب Firebase هاش كلمة المرور؟
يحفظ Firebase Authentication كلمات المرور بنسخة معدلة من خوارزمية scrypt، وقد نشرت Google تنفيذها في مستودع firebase/scrypt، وملف README فيه يشرح الطريقة: لكل مشروع معاملات خاصة به تراها في لوحة Firebase تحت Authentication ثم Users ثم Password Hash Parameters، وهي مفتاح التوقيع Signer Key وفاصل الملح Salt Separator وعدد الجولات Rounds وكلفة الذاكرة Mem Cost، ولكل مستخدم ملح Salt خاص به. ويصدر الأمر firebase auth:export، كما في توثيق أوامر Auth، لكل مستخدم حقلي passwordHash وsalt. والحساب كما في الصورة التالية:

وهذا يعني أن النظام الجديد لا يكفيه هاش المستخدم وملحه، وإنما يحتاج معاملات المشروع الأربعة أيضاً، وإذا أخطأ في واحد منها فشل دخول الجميع. ولأن المحاكي لا يعطينا هاشاً حقيقياً، كتبنا الخوارزمية بمكتبة crypto المدمجة في Node.js، وتحققنا منها بالمثال المنشور في README نفسه قبل أن نعتمد عليها:
// Firebase's modified scrypt, as described in github.com/firebase/scrypt:
// key = scrypt(password, salt + saltSeparator, N = 2^memCost, r = rounds, p = 1), then AES-256-CTR(signerKey) with that key.
import { scryptSync, createCipheriv, timingSafeEqual } from 'node:crypto'
export function firebaseScrypt(password, saltB64, { signerKey, saltSeparator, rounds, memCost }) {
const salt = Buffer.concat([Buffer.from(saltB64, 'base64'), Buffer.from(saltSeparator, 'base64')])
const N = 2 ** memCost
const key = scryptSync(Buffer.from(password, 'utf8'), salt, 64, { N, r: rounds, p: 1, maxmem: 256 * N * rounds })
const aes = createCipheriv('aes-256-ctr', key.subarray(0, 32), Buffer.alloc(16, 0))
return Buffer.concat([aes.update(Buffer.from(signerKey, 'base64')), aes.final()]).toString('base64')
}
export const verify = (password, saltB64, hashB64, params) =>
timingSafeEqual(Buffer.from(firebaseScrypt(password, saltB64, params), 'base64'), Buffer.from(hashB64, 'base64'))
// Self-test with the sample from the firebase/scrypt README
if (process.argv[1].endsWith('fbscrypt.mjs')) {
const params = { signerKey: 'jxspr8Ki0RYycVU8zykbdLGjFQ3McFUH0uiiTvC8pVMXAn210wjLNmdZJzxUECKbm0QsEmYUSDzZvpjeJ9WmXA==',
saltSeparator: 'Bw==', rounds: 8, memCost: 14 }
const t0 = performance.now()
const got = firebaseScrypt('user1password', '42xEC+ixf3L2lw==', params)
console.log('hash ', got)
console.log('expected', 'lSrfV15cpx95/sZS2W9c9Kp6i/LVgQNDNC/qzrCnh1SAyZvqmZqAjTdn3aoItz+VHjoZilo78198JAdRuid5lQ==')
console.log('match:', verify('user1password', '42xEC+ixf3L2lw==', got, params), ' wrong password:', verify('user1passw0rd', '42xEC+ixf3L2lw==', got, params),
` (${Math.round(performance.now() - t0)} ms)`)
}hash lSrfV15cpx95/sZS2W9c9Kp6i/LVgQNDNC/qzrCnh1SAyZvqmZqAjTdn3aoItz+VHjoZilo78198JAdRuid5lQ==
expected lSrfV15cpx95/sZS2W9c9Kp6i/LVgQNDNC/qzrCnh1SAyZvqmZqAjTdn3aoItz+VHjoZilo78198JAdRuid5lQ==
match: true wrong password: false (257 ms)فالناتج طابق المثال الرسمي حرفاً بحرف، وكلمة المرور الخاطئة رفضت، والحساب أخذ قرابة ربع ثانية، وهذا البطء مقصود في scrypt، فهو ما يجعل تجربة ملايين كلمات المرور على هاش مسرب مكلفة، كما شرحنا في كلمات المرور للمبتدئين. بعد ذلك ولدنا معاملات مشروع تجريبية، وحسبنا لكل مستخدم من المحاكي هاشاً حقيقياً بكلمة مروره، وكتبناه بالشكل الذي يصدره auth:export في مشروع حقيقي:
[email protected] Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU salt q4S3FATQ848Z4kRk hash yTautHWsep4DmDnzbTmDmE4R…
[email protected] NJfHQBbpq3a6cRByUE7zEnEn4j4B salt Rp6Pp3tsG5ivLhrq hash BH9pvt1Zz4CIWk73YA9DAHU8…
hash_config: rounds 8 mem_cost 14 salt_separator Bw== signer_key arcCDy/VOcFX…ومن هنا فصاعداً لا يعرف الاستيراد كلمة المرور الواضحة، وإنما الهاش والمعاملات فقط، تماماً كما في انتقال حقيقي.
auth:export ومعاملات الهاش معاً يكفيان لمهاجم أن يبدأ تخمين كلمات مرور مستخدميك على جهازه، فعاملهما معاملة أسرار الإنتاج: لا تضعهما في مستودع Git ولا في محادثة، واحذفهما بعد انتهاء الانتقال، وقيد من يملك دور Identity Toolkit Viewer في مشروع Firebase.مستخدمو Google وApple ورقم الجوال
كل ما سبق عن الهاش يخص من سجل بالبريد وكلمة المرور، أما بقية المستخدمين فطريقهم مختلف، ويجب أن تعرف عددهم من الجرد قبل يوم التحويل. فمن سجل بحساب Google أو Apple لا كلمة مرور له عندك أصلاً، وإنما ربط بين حسابه عند المزود وحسابه في تطبيقك، والملف الذي يصدره auth:export يحمل لكل منهم قائمة providerUserInfo بمعرفه عند المزود وبريده. والذي يحدث بعد الانتقال أن المستخدم يضغط زر الدخول بحساب Google كما كان، فيعود إلى النظام الجديد ببريده، والسؤال هو: هل يربطه النظام بالحساب المستورد نفسه أم ينشئ حساباً جديداً فارغاً؟ والجواب يعتمد على إعدادات ربط الحسابات بالبريد في كل نظام، فاختبره بحساب حقيقي قبل التحويل، لأن الحساب الفارغ يعني مستخدماً يظن أن بياناته ضاعت. وتذكر أن معرفات تطبيقك عند Google وApple، أي Client ID وما يقابله، تنتقل إلى إعدادات النظام الجديد، وأن عناوين إعادة التوجيه Redirect URLs تتغير، فحدثها عند المزودين قبل يوم التحويل. أما المستخدمون برقم الجوال فلا كلمة مرور لهم أيضاً، ويدخلون برمز يصلهم، فيكفي أن ينتقل رقم الجوال مؤكداً، ويحتاج النظام الجديد مزود رسائل نصية تضبطه. والمستخدمون المجهولون Anonymous لا يمكن تمييزهم بعد الانتقال إلا بمعرفهم، فإذا كانت لهم بيانات تهمهم فقرر هل تنقلها أم تطلب منهم إنشاء حساب قبل التحويل.
كم يكلف كل دخول بعد الانتقال؟
رقم ربع الثانية في المخرج السابق ليس تفصيلاً، فهو زمن معالج CPU كامل لحساب هاش واحد، وفي Firebase كان هذا العمل على سيرفرات Google، أما بعد الانتقال فهو على سيرفرك. والحساب البسيط أن نواة معالج واحدة تتحقق من قرابة أربع كلمات مرور في الثانية بهذه المعاملات، فإذا كان تطبيقك يستقبل في ساعة الذروة مئة عملية دخول في الثانية، كبداية دوام أو إعلان في رمضان، فأنت تحتاج قرابة 25 نواة للتحقق من كلمات المرور وحده، وهذا قبل أي عمل آخر. والرقم ينخفض مع الوقت في Appwrite لأنه يعيد الحساب ب argon2 بعد كل دخول ناجح، وفي Supabase يبقى الهاش كما هو حتى يغير المستخدم كلمة مروره، فإذا كان عدد مستخدميك كبيراً فراقب استخدام المعالج في خدمة المصادقة الأيام الأولى بعد التحويل، واجعل تحديد معدل الطلبات Rate Limiting على مسار الدخول مضبوطاً، لأن من يجرب كلمات مرور على حساب واحد يستهلك المعالج نفسه، كما شرحنا في تحديد معدل الطلبات.
الاستيراد إلى Supabase: طريقتان
شغلنا لهذا الجزء خدمات Supabase المستضاف التي يحتاجها الاستيراد، بالإصدارات نفسها التي ثبتناها في دليل Supabase، أي قاعدة البيانات Database والمصادقة GoTrue وPostgREST والتحديث الفوري Realtime والتخزين والبوابة.
الطريقة الأولى: أداة import_users الرسمية
الأداة import_users.js في المستودع نفسه تقرأ ملف المستخدمين وتدخلهم مباشرة في الجدول auth.users باتصال PostgreSQL:
docker run --rm --network sc5-sb-net -v "$PWD/f2s:/f2s" -w /f2s/auth node:22-alpine node import_users.js users.json
docker exec sc5-sb-db psql -U postgres -At -c "select email, length(encrypted_password), raw_user_meta_data->'fbuser'->>'uid', left(raw_user_meta_data->'fbuser'->>'passwordHash',30) from auth.users where email in ('[email protected]','[email protected]')"
curl -s "http://127.0.0.1:28000/auth/v1/token?grant_type=password" -H "apikey: $PK" -H 'content-type: application/json' -d '{"email":"[email protected]","password":"Sara-Old-Pass-1"}'loading users from users.json
insertUsers: 2
finished
done processing users.json
[email protected]|0|Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU|fakeHash:salt=fakeSaltnqiSt5DS
[email protected]|0|NJfHQBbpq3a6cRByUE7zEnEn4j4B|fakeHash:salt=fakeSaltxjiFX211
{"code":400,"error_code":"invalid_credentials","msg":"Invalid login credentials"}فالأداة تترك encrypted_password فارغاً، أي بطول صفر، وتضع بيانات Firebase كاملة مع الهاش داخل raw_user_meta_data تحت المفتاح fbuser، ولذلك فشل الدخول. والفكرة في المستودع أن تضع أمام شاشة الدخول سيرفراً وسيطاً Middleware اسمه verify-firebase-pw، يتحقق من كلمة المرور بهاش Firebase عند أول دخول، ثم يكتبها في Supabase بالطريقة العادية. وعندما قرأنا كود هذا السيرفر وجدنا أنه يقبل كلمة المرور في مسار طلب GET نفسه، أي /:salt/:hash/:password، والمسارات تكتب عادة في سجلات ال Reverse Proxy والسيرفر، فلا تقم باستخدامه كما هو، وإذا اضطررت إليه فاقبل الطلب ب POST فقط وأوقف تسجيل المسارات. ولاحظ أيضاً أن الأداة تبني جملة SQL بدمج النصوص مباشرة، فبريد يحتوي علامة تنصيص يفشل الإدخال كله.
الطريقة الثانية: هاش Firebase مباشرة في GoTrue
منذ الإصدار v2.162.0 بتاريخ 27 سبتمبر 2024 تقبل خدمة المصادقة في Supabase هاش Firebase نفسه، كما في سجل تغييرات supabase/auth، فتمرره في الحقل password_hash عند إنشاء المستخدم من واجهة الإدارة، بصيغة تبدأ ب $fbscrypt$ وتحمل المعاملات كلها. وهذا السكربت هو ما شغلناه:
// Firebase users into Supabase Auth with their old passwords: GoTrue (v2.162.0+) accepts Firebase scrypt hashes
// in the admin API as "$fbscrypt$v=1,n=<mem_cost>,r=<rounds>,p=1,ss=<salt_separator>,sk=<signer_key>$<salt>$<hash>".
import { createClient } from '@supabase/supabase-js'
import { readFileSync } from 'node:fs'
const URL = process.env.SB_URL
const admin = createClient(URL, process.env.SB_SECRET, { auth: { persistSession: false } })
const p = JSON.parse(readFileSync('../hash/hash-params.json', 'utf8'))
const { users } = JSON.parse(readFileSync('../hash/users-scrypt.json', 'utf8'))
const N = process.env.N ?? p.memCost // what goes in n=, see the text
for (const u of users) {
const password_hash = ['', 'fbscrypt', `v=1,n=${N},r=${p.rounds},p=1,ss=${p.saltSeparator},sk=${p.signerKey}`, u.salt, u.passwordHash].join('$')
const { data, error } = await admin.auth.admin.createUser({ email: u.email, password_hash, email_confirm: true,
user_metadata: { firebase_uid: u.localId } })
console.log('import', u.email, error ? `-> ${error.status} ${error.message}` : `-> ${data.user.id}`)
}
const login = async (email, password) => {
const { data, error } = await createClient(URL, process.env.SB_KEY, { auth: { persistSession: false } }).auth.signInWithPassword({ email, password })
return error ? `${error.status} ${error.message}` : `OK, token for ${data.user.email}, firebase_uid ${data.user.user_metadata.firebase_uid}`
}
console.log('login sara, old password ->', await login('[email protected]', 'Sara-Old-Pass-1'))
console.log('login sara, wrong password ->', await login('[email protected]', 'Sara-Old-Pass-X'))
console.log('login omar, old password ->', await login('[email protected]', 'Omar-Old-Pass-2'))وفي المحاولة الأولى وضعنا في n= القيمة 16384، لأن هذا هو معامل scrypt المعروف N، فنجح الإنشاء وفشل كل دخول:
import [email protected] -> cfbc7457-89f0-4bcc-bb2e-85f0f770e3e3
import [email protected] -> 2355475a-6b2f-4000-9c35-d057962aa67b
login sara, old password -> 500 Internal Server Error
login sara, wrong password -> 500 Internal Server Error
login omar, old password -> 500 Internal Server Errordocker logs sc5-sb-auth 2>&1 | grep -i scrypt | tail -1 | cut -c1-120{"level":"error","msg":"request panicked","panic":"scrypt: N must be \u003e 1 and a power of 2","stack":"goroutine 512 [running]:…وبقراءة ملف password.go في الإصدار الذي نشغله وجدنا السبب: الخدمة تحسب الذاكرة بإزاحة 1 << n، أي أن n هو الأس، أي mem_cost نفسه 14، وليس 2 مرفوعة إليه، وإزاحة 1 بمقدار 16384 بت في Go تعطي صفراً، فوصل إلى scrypt المعامل صفر. ولاحظ أن الإنشاء لم يرفض الهاش، فالخطأ لا يظهر إلا عند أول دخول، أي عند المستخدمين وليس عندك. فحذفنا المستخدمين وأعدنا الاستيراد بالقيمة الصحيحة:
import [email protected] -> e191bd9c-855f-4070-93cb-04ee573a4a18
import [email protected] -> c47f88ac-bb36-47b5-9133-acdf1b1ddecd
login sara, old password -> OK, token for [email protected], firebase_uid NJfHQBbpq3a6cRByUE7zEnEn4j4B
login sara, wrong password -> 400 Invalid login credentials
login omar, old password -> OK, token for [email protected], firebase_uid Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU
[email protected]|$fbscrypt$v=1,n=14,r=8,p=1,ss=Bw==,sk=ar…|Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU
[email protected]|$fbscrypt$v=1,n=14,r=8,p=1,ss=Bw==,sk=ar…|NJfHQBbpq3a6cRByUE7zEnEn4j4Bفدخلت سارة وعمر بكلمتي مرورهما القديمتين، ورفضت الكلمة الخاطئة. وفي الإعداد أعلاه لاحظ التالي:
- اختبر الدخول بمستخدم واحد مستورد قبل أن تستورد الباقين، والسبب أن خطأ المعاملات لا يظهر عند الإنشاء.
- الهاش بقي بصيغة
$fbscrypt$بعد الدخول، فدالة المصادقة في هذا الإصدار تعيد حساب هاش bcrypt فقط إذا كانت كلفته غير مناسبة، وتستثني صيغ argon2 وfbscrypt، وهذا يعني أن مفتاح توقيع مشروع Firebase محفوظ في كل صف من صفوف المستخدمين القدامى إلى أن يغير كل منهم كلمة مروره. - المعرف الجديد UUID، والقديم في
user_metadata.firebase_uid، وسوف نحتاجه في البيانات الآن.
خيار ثالث: تبقي Firebase Auth وتنقل البيانات أولاً
قد يتساءل البعض: هل يجب أن ينتقل كل شيء في يوم واحد؟ والإجابة لا، فتوثيق Supabase فيه صفحة Firebase Auth كمصادقة خارجية، أي أن Supabase يقبل توكن ID الذي يصدره Firebase Auth للمستخدم، ويستخدمه في سياسات RLS كأنه توكن خاص به. وهذا يسمح بانتقال على مرحلتين: تنقل البيانات إلى PostgreSQL وتبقي التطبيق يسجل الدخول عبر Firebase كما هو، ثم تنقل المستخدمين لاحقاً بعد أن تستقر البيانات، فيصبح كل يوم تحويل أصغر وأسهل في التراجع. ولاحظ تحذيرين: الأول أن الصفحة نفسها تنبه من يستخدم هذه الطريقة في النسخة المستضافة إلى أن يكتب سياسات RLS مقيدة على كل الجداول والتخزين والتحديث الفوري، حتى لا يدخل مستخدمون من مشاريع Firebase أخرى بتوكنات صحيحة التوقيع لكنها لا تخص مشروعك، فاجعل كل سياسة تتحقق من معرف المشروع في التوكن. والثاني أن هذه المرحلة لا تحل مسألة إقامة البيانات، لأن المصادقة نفسها ما زالت عند Google، وصفحة الخصوصية في Firebase تذكر أن خدمة المصادقة تعالج البيانات في الولايات المتحدة، كما ذكرنا في مقال BaaS، فإذا كان الانتقال بسبب النظام فالمرحلة الثانية ليست اختيارية.
البيانات: الجداول، ثم إعادة ربط المالك
الأداة json2supabase.js تنشئ لكل ملف JSON جدولاً بأعمدة من الأنواع النصية والرقمية والمنطقية وjsonb، ثم تدخل الصفوف، وأول تشغيل لها على المهام أعطى هذا:
analyzing fields in todos.json
creating destination table for todos.json
data type mismatch for field owner: uuid, textوالسبب أن اسم الجدول يؤخذ من اسم الملف، وكان عندنا جدول todos بتصميم جديد فيه owner من نوع uuid، فرفضت الأداة أن تكتب فيه نصاً. وهذا تذكير بأن الشكل القديم والشكل الجديد مختلفان، والطريقة الصحيحة أن تستورد إلى جدول مرحلي Staging باسم مختلف ثم تنقل منه بكود. فنسخنا الملف باسم fb_todos.json:
node json2supabase.js products.json firestore_id
node json2supabase.js fb_todos.json firestore_id
node json2supabase.js orders.json firestore_id
docker exec sc5-sb-db psql -U postgres -c 'select id, name, price, tags, stock from public.products' id | name | price | tags | stock
----+------------+-------+--------------------+-----------------------------
p1 | قهوة عربية | 45.5 | ["coffee", "gift"] | {"jeddah": 0, "riyadh": 12}
p2 | تمر سكري | 60 | ["dates"] | {"jeddah": 8, "riyadh": 30}والخرائط المتداخلة والمصفوفات صارت أعمدة jsonb، وهذا يكفي للبداية، لكن التصميم الأفضل لمخزون الفروع مثلاً جدول مستقل، كما شرحنا في تصميم قواعد البيانات. ثم جاءت المفاجأة الأخطر، فقد طلبنا جدول الطلبات بالمفتاح العام دون أي تسجيل دخول:
curl -s "http://127.0.0.1:28000/rest/v1/orders?select=id,uid,total" -H "apikey: $PK"[{"id":"YB1Dvqy7cBYowEGPwHqS","uid":"NJfHQBbpq3a6cRByUE7zEnEn4j4B","total":151}]فالأداة تنشئ الجداول في المخطط public دون RLS، وكل جدول في هذا المخطط يصبح جزءاً من الواجهة البرمجية API، أي أن طلبات المستخدمين كانت مفتوحة لأي شخص في اللحظة التي انتهى فيها الاستيراد، وهذه هي الحالة نفسها التي شرحناها في دليل Supabase. فأغلقنا الجداول، ثم نقلنا المهام إلى جدولها الجديد وربطنا كل مهمة بالمستخدم الجديد عبر المعرف القديم:
-- the tool creates tables in public without RLS: close them first
alter table public.orders enable row level security;
alter table public.products enable row level security;
alter table public.fb_todos enable row level security;
create policy "anyone reads products" on public.products for select to anon, authenticated using (true);
-- re-link each todo to the new Supabase user through the old Firebase uid
insert into public.todos (owner, title, done, created_at)
select u.id, t.title, t.done, to_timestamp((t.created->>'_seconds')::bigint)
from public.fb_todos t join auth.users u on u.raw_user_meta_data->>'firebase_uid' = t.owner;ALTER TABLE
ALTER TABLE
ALTER TABLE
CREATE POLICY
INSERT 0 3
--- anonymous GET /rest/v1/orders after RLS:
[]
--- sara (old password) GET /rest/v1/todos:
[{"title":"خطة الإطلاق","done":false,"created_at":"2026-11-19T21:27:23+00:00"},
{"title":"مراجعة العقود","done":false,"created_at":"2026-11-19T21:27:25+00:00"}]فالزائر لم يعد يرى شيئاً، وسارة دخلت بكلمة مرورها القديمة ورأت مهمتيها فقط بسياسة الجدول الجديد، والتاريخ عاد تاريخاً. والصورة التالية تبين إعادة الربط في الأنظمة الثلاثة:

الاستيراد إلى Appwrite
Appwrite يقدم في واجهة المستخدمين نقطة نهاية خاصة بهاش Firebase اسمها Scrypt Modified، كما في مرجع واجهة المستخدمين، ويقبل أن تحدد أنت معرف المستخدم، والمعرف حتى 36 حرفاً من الحروف والأرقام، فيدخل معرف Firebase المكون من 28 حرفاً كما هو، وهذا يوفر خطوة إعادة الربط كلها:
for (const u of fbUsers) {
const r = await users.createScryptModifiedUser({ userId: u.localId, email: u.email, password: u.passwordHash,
passwordSalt: u.salt, passwordSaltSeparator: p.saltSeparator, passwordSignerKey: p.signerKey })
console.log('import', u.email, '->', r.$id, r.hash, JSON.stringify(r.hashOptions).slice(0, 60) + '…')
}
// todos keep their owner: the row permissions name the same uid Firebase used
for (const t of JSON.parse(readFileSync('../json/todos.json', 'utf8'))) {
const own = [Permission.read(Role.user(t.owner)), Permission.update(Role.user(t.owner)), Permission.delete(Role.user(t.owner))]
await db.createRow({ databaseId: 'todo', tableId: 'todos', rowId: t.firestore_id, data: { title: t.title, done: t.done }, permissions: own })
}import [email protected] -> Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU scryptMod {"type":"scryptMod","salt":"q4S3FATQ848Z4kRk","saltSeparator…
import [email protected] -> NJfHQBbpq3a6cRByUE7zEnEn4j4B scryptMod {"type":"scryptMod","salt":"Rp6Pp3tsG5ivLhrq","saltSeparator…
todos imported with their Firebase ids
login sara, old password -> 201 session for user NJfHQBbpq3a6cRByUE7zEnEn4j4B
login sara, wrong password -> 401 Invalid credentials. Please check the email and password.
login omar, old password -> 201 session for user Hxx6Xg6JDOMJFTrUPrQHVRQjTHNUثم سألنا Appwrite عن هاش سارة بعد دخولها:
curl -s http://localhost:28880/v1/users/NJfHQBbpq3a6cRByUE7zEnEn4j4B -H "X-Appwrite-Project: $P" -H "X-Appwrite-Key: $AW_KEY"argon2 {"type":"argon2","memory_cost":7168,"time_cost":5,"threads":1}فعلى عكس Supabase، أعاد Appwrite حساب الهاش بخوارزمية argon2 عند أول دخول ناجح، فاختفى مفتاح مشروع Firebase من حساب سارة، وبقي عند من لم يدخل بعد. ولاحظ أن نقطة النهاية لا تأخذ عدد الجولات وكلفة الذاكرة، فهي تفترض قيم Firebase الافتراضية 8 و14، وهي القيم التي رأيناها في مثال README، فقارنها بمعاملات مشروعك قبل أن تبدأ. والصورة التالية من صفحة المستخدمين بعد الاستيراد، والمعرفان هما معرفا Firebase نفسيهما:

وفي لوحة Appwrite أداة انتقال مدمجة Migrations تنقل من Firebase المستخدمين وFirestore والملفات بخطوة واحدة، لكنها تتصل بمشروع Firebase حقيقي عبر حساب خدمة بالدورين Firebase Viewer وIdentity Toolkit Viewer، فلا تعمل مع المحاكي، وصفحتها تذكر حدودها بوضوح: Firestore فقط دون Realtime Database، والمستوى الأول دون الصفوف المتداخلة، ودون مستخدمي OAuth الذين يجب أن يسجلوا الدخول من جديد عند مزودهم، ودون الدوال. وهذه الحدود نفسها التي رأيناها في أدوات Supabase، فهي حدود Firestore نفسه أكثر من حدود الأدوات.
الاستيراد إلى PocketBase
PocketBase يحفظ كلمات المرور ب bcrypt فقط، ولا يقبل هاش Firebase، فالطريق الوحيد دون كتابة امتداد بلغة Go هو أن تنشئ كل حساب بكلمة مرور عشوائية وترسل للمستخدم رابط استعادة. والسكربت التالي أضاف حقلاً يحفظ المعرف القديم، وأنشأ المستخدمين، ونقل المهام بخريطة من المعرف القديم إلى الجديد:
const users = await pb.collections.getOne('users')
if (!users.fields.find(f => f.name === 'firebase_uid'))
await pb.collections.update('users', { fields: [...users.fields, { type: 'text', name: 'firebase_uid' }] })
const idMap = {}
for (const u of fbUsers) {
const pw = randomBytes(18).toString('base64url')
const rec = await pb.collection('users').create({ email: u.email, password: pw, passwordConfirm: pw, firebase_uid: u.localId, verified: u.emailVerified })
idMap[u.localId] = rec.id
}
for (const t of JSON.parse(readFileSync('../json/todos.json', 'utf8')))
await pb.collection('todos').create({ title: t.title, done: t.done, owner: idMap[t.owner] })
const old = await new PocketBase(process.env.PB_URL).collection('users').authWithPassword('[email protected]', 'Sara-Old-Pass-1').catch(e => e)
console.log('login sara with her old password ->', old.status, old.response?.message)
await pb.collection('users').requestPasswordReset('[email protected]').then(() => console.log('password reset requested for sara'))user [email protected] Hxx6Xg6JDOMJFTrUPrQHVRQjTHNU -> pgsxpkqclxh27zq
user [email protected] NJfHQBbpq3a6cRByUE7zEnEn4j4B -> m2r3ygyg9r70q25
todo 8xGHKQGMkKpjfNoqdvaD -> tb1e2u0xd15lwlb owner m2r3ygyg9r70q25
todo QvYJHElmutQ1GA4UUzBg -> gw6os0rwv7aokpa owner pgsxpkqclxh27zq
todo dfeD88icewD7yG6iVDlm -> wch9avb04boxvug owner m2r3ygyg9r70q25
login sara with her old password -> 400 Failed to authenticate.
password reset requested for saraوالطلب نجح، لكن سجل PocketBase يقول غير ذلك:
8|Failed to send password reset email|exit status 1فلم نضبط سيرفر بريد، وPocketBase يستخدم افتراضياً الأمر sendmail غير الموجود في ال Container، أي أن الواجهة ترد بالنجاح والرسالة لم تخرج، وفي انتقال حقيقي هذا يعني آلاف المستخدمين ينتظرون رسالة لا تصل، فاضبط SMTP واختبر رسالة واحدة قبل أن ترسل لأحد، وإذا لم يكن عندك سيرفر بريد فقد شرحنا البريد التفاعلي Transactional Email. والصورة التالية تجمع ما حدث لكلمة مرور سارة في الأنظمة الثلاثة:

من قواعد Firebase إلى سياسات RLS والصلاحيات
قواعد الأمان لا تنتقل بأي أداة، وكل قاعدة تعاد كتابتها بلغة النظام الجديد، والجدول التالي يضع كل قاعدة من ملف firestore.rules في المختبر أمام ما يقابلها:
| قاعدة Firebase | Supabase (RLS) | Appwrite | PocketBase |
|---|---|---|---|
read, update, delete: if request.auth.uid == resource.data.owner | using ((select auth.uid()) = owner) | صلاحيات الصف read/update/delete(user:<id>) مع rowSecurity | owner = @request.auth.id في List وView وUpdate وDelete |
create: if request.auth.uid == request.resource.data.owner | with check ((select auth.uid()) = owner) | create(users) على الجدول، والمالك من صلاحيات الصف | @request.auth.id != '' && owner = @request.auth.id |
request.resource.data.title.size() <= 200 | قيد check (char_length(title) <= 200) | حجم العمود size: 200 | الحقل max: 200 |
products: read: if true; write: if false | سياسة select ل anon وauthenticated، دون سياسات كتابة | read(any) على الجدول ودون صلاحيات كتابة | listRule و viewRule فارغة، والكتابة null |
items: get(/orders/$(orderId)).data.uid == request.auth.uid | سياسة فيها exists (select 1 from orders o where o.id = order_id and o.uid = auth.uid()) | لا يوجد شرط عابر للجداول، فتنسخ صلاحيات الطلب إلى كل عنصر | order.uid = @request.auth.id عبر حقل العلاقة |
في الجدول أعلاه لاحظ التالي:
- القواعد التي تقرأ مستنداً آخر بالدالة
get()هي الأصعب نقلاً، ففي SQL تصبح استعلاماً فرعياً بفهرس مناسب، وفي PocketBase تصبح مساراً عبر حقل علاقة، وفي Appwrite لا يوجد مقابل مباشر، فتنسخ الصلاحيات أو تنقل القراءة إلى دالة. - القواعد التي تتحقق من شكل البيانات، كطول العنوان ونوعه، تصبح في SQL قيوداً Constraints، وهذا أقوى، لأن القيد يطبق على كل كتابة حتى من السيرفر.
- القاعدة
write: if falseفي Firebase تعني «من السيرفر فقط»، وفي PocketBase يقابلهاnullوليس النص الفارغ، والنص الفارغ هناك يعني «للجميع»، كما شرحنا في دليل PocketBase. - بعد كتابة كل قاعدة اختبرها بطلب دون تسجيل، وبطلب من مستخدم آخر، كما فعلنا في أدلة الأنظمة الثلاثة، فالقاعدة التي لم تختبر لم تكتب بعد.
الملفات والدوال: الجزء الذي لا ينتقل وحده
الملفات في Cloud Storage أبسط الأجزاء من حيث الأدوات، وأصعبها من حيث الروابط. فالتنزيل والرفع عمليتان معروفتان، والمستودع نفسه فيه سكربتان لذلك في مجلد storage، لكن المشكلة الحقيقية أن بياناتك تحفظ غالباً روابط الملفات كاملة، وروابط Firebase تحمل اسم المشروع وتوكن تنزيل في آخرها، فبعد نقل الملفات يبقى كل حقل صورة في قاعدة البيانات يشير إلى Google. ولذلك احفظ في البيانات الجديدة مسار الملف داخل المجلد فقط، أي users/<uid>/avatar.jpg، وابن الرابط في التطبيق أو اطلب رابطاً موقعاً Signed URL عند الحاجة، كما شرحنا في S3 من داخل تطبيقك، وحول الحقول القديمة بسكربت أثناء الاستيراد. والمسار نفسه يحمل الصلاحية في Supabase، فمجلد اسمه معرف المستخدم هو ما تبني عليه سياسة التخزين، ولذلك يجب أن يكون المعرف هنا هو المعرف الجديد، أو أن تبقي القديم وتربط به كما فعلنا في البيانات.
أما الدوال فلا يوجد ما ينقلها، والسبب أن الكود نفسه عندك، لكن الذي يطلقه مختلف في كل نظام، والجدول التالي يضع أشيع المحفزات في Firebase أمام ما يقابلها:
| المحفز في Firebase | Supabase | Appwrite | PocketBase |
|---|---|---|---|
عند إنشاء مستند onDocumentCreated | Trigger في PostgreSQL، أو Database Webhook يستدعي دالة | دالة مربوطة بحدث rows.*.create | onRecordAfterCreateSuccess في pb_hooks |
دالة يستدعيها التطبيق onCall وonRequest | Edge Function | تنفيذ دالة createExecution أو نطاق الدالة | routerAdd |
جدولة onSchedule | pg_cron داخل القاعدة | الحقل schedule للدالة | cronAdd |
| عند إنشاء مستخدم | Trigger على auth.users | حدث users.*.create | Hook على مجموعة users |
ولاحظ أن محفزات Firestore تعمل بعد الكتابة وبضمان «مرة واحدة على الأقل»، أي قد تعمل الدالة مرتين للحدث نفسه، والكود المكتوب لها يجب أن يكون قابلاً للتكرار دون ضرر أصلاً، وهذا يسهل نقله، أما الكود الذي يفترض أنه يعمل مرة واحدة بالضبط فراجعه قبل نقله، لأن النظام الجديد قد يختلف في هذا الضمان.
التحقق بعد الاستيراد Verification
لا تقم بإعلان نجاح الانتقال لأن السكربت انتهى دون أخطاء، فقد رأيت في هذا المقال سكربتاً نجح وترك عناصر الطلبات خلفه، واستيراداً نجح وكل دخول بعده فشل، وأداة نجحت وتركت جداولها مفتوحة للجميع. والتحقق الذي نقترحه له أربعة أجزاء:
- الأعداد: عدد المستخدمين وعدد السجلات في كل جدول مقابل الجرد الذي كتبته قبل الانتقال، وعدد الملفات وحجمها الإجمالي.
- العينة: عشرون سجلاً عشوائياً من كل نوع، تقارن حقولها بالمصدر حقلاً بحقل، والتواريخ والأرقام العشرية خصوصاً.
- الدخول: حسابات أعضاء الفريق الحقيقية بكلمات مرورهم، ومستخدم بكل طريقة دخول، ومستخدم كان معطلاً للتأكد أنه ما زال معطلاً.
- الصلاحيات: طلب دون تسجيل على كل جدول، وطلب من مستخدم على بيانات مستخدم آخر، كما فعلنا في Supabase عندما وجدنا جدول الطلبات مفتوحاً.
خطة التحويل: من يوم الاستيراد إلى إغلاق Firebase
الاستيراد خطوة واحدة في انتقال حقيقي، والصعب هو أن التطبيق القديم ما زال في هواتف الناس، والمستخدم الذي لم يحدث التطبيق سيبقى يكتب في Firebase. وهذه هي الخطة التي نقترحها:
- طبقة بيانات واحدة في التطبيق: قبل الانتقال بأشهر، اجعل كل الشاشات تكلم ملفاً واحداً يكلم Firebase، كما ذكرنا في مقال BaaS، فيصبح تغيير المزود تعديل ملف واحد.
- بروفة كاملة: صدر المستخدمين والبيانات إلى سيرفر اختبار، واستورد، وادخل بعشرة حسابات حقيقية لأعضاء الفريق بكلمات مرورهم، وقارن عدد السجلات في كل مجموعة.
- نافذة القراءة فقط: اجعل قواعد Firebase تمنع الكتابة في وقت محدد، ثم صدر التصدير النهائي، فلا يكتب أحد بعد التصدير ويضيع ما كتبه.
- إصدار جديد من التطبيق: يكلم الخلفية الجديدة، واجعل الإصدار القديم يعرض رسالة تطلب التحديث بدل أن يفشل بصمت، وهذا يحتاج أن يكون في التطبيق القديم فحص لرقم الإصدار الأدنى، فإذا لم يكن موجوداً فأضفه الآن.
- إبقاء Firebase للقراءة فترة: لا تحذف المشروع في يوم التحويل، وأبقه للقراءة حتى تتأكد أن كل شيء انتقل.
- الإشعارات: FCM وAPNs لا ينتقلان مع البيانات، والقرار فيهما مستقل، كما في مقال الإشعارات بدون Firebase.
- الحذف: احذف ملفات التصدير ومعاملات الهاش من كل جهاز وسيرفر، ثم احذف بيانات المستخدمين من Firebase إذا كان هذا مطلوباً نظاماً، كما في نظام حماية البيانات الشخصية.
متى لا تنتقل؟
هذا مقال عن الانتقال، لكن القرار الصادق يحتاج الجانب الآخر أيضاً، فالانتقال مشروع له كلفة حقيقية: أسابيع من عمل المطورين، وإصدار جديد للتطبيق، ومخاطرة في يوم التحويل، ثم سيرفرات تتابعها أنت بعد أن كانت Google تتابعها. ولذلك لا ننصح بالانتقال في الحالات التالية:
- تطبيق صغير يعمل جيداً ولا يوجد سبب نظامي: إذا كانت فاتورة Firebase صغيرة ولا يوجد شرط لإقامة البيانات، فالانتقال يحل مشكلة غير موجودة، والأفضل أن تضيف طبقة البيانات الواحدة في التطبيق الآن، فيصبح الانتقال سهلاً يوم تحتاجه.
- اعتماد كبير على خدمات لا بديل لها: إذا كان تطبيقك يعتمد على Test Lab وApp Check وCrashlytics وRemote Config معاً، فنقل قاعدة البيانات وحدها يتركك في نظامين، وهذا مقبول، لكن احسبه قبل أن تبدأ.
- فريق بلا خبرة تشغيل: الخلفية المستضافة تحتاج من يحدثها ويراقبها وينسخها ويستعيدها، فإذا لم يكن في الفريق من يفعل ذلك، فالنسخة السحابية من Supabase أو Appwrite تعطيك قابلية النقل دون عبء التشغيل، ثم تنتقل إلى سيرفرك لاحقاً بالأدوات نفسها، كما ناقشنا في الاستضافة الذاتية: متى تكون قراراً استراتيجياً.
وفي المقابل فالانتقال ليس خياراً عندما يشترط النظام إقامة بيانات المستخدمين داخل الدولة، والسبب الذي ذكرناه أكثر من مرة أن خدمة المصادقة في Firebase تعالج البيانات في الولايات المتحدة، ولا يوجد إعداد يغير ذلك.
أخطاء شائعة
- الاعتماد على ملف تصدير المحاكي: فيه كلمات مرور واضحة ولا يوجد فيه هاش حقيقي.
- n=16384 في صيغة fbscrypt: الصحيح mem_cost، أي 14، والخطأ لا يظهر إلا عند أول دخول.
- نسيان المجموعات الفرعية: الأدوات تقرأ المستوى الأول فقط، ولا تخبرك بما تركته.
- جداول دون RLS بعد الاستيراد: json2supabase ينشئها مفتوحة في
public. - معرف Firebase في عمود uuid: لا يدخل، فاحفظ المعرف القديم واربط به.
- التواريخ كائنات: حولها ب
to_timestampأو ما يقابلها. - معاملات هاش مختلفة عن الافتراضية مع Appwrite: نقطة النهاية تفترض 8 و14.
- إرسال روابط الاستعادة دون SMTP مضبوط: الواجهة تقول نجح، والرسالة لم تخرج.
- ترك ملف auth:export على جهاز مطور: هو ومعاملات الهاش بداية هجوم تخمين.
والقاعدة التي تجمع هذه الأخطاء أن كل خطوة في الانتقال يمكن أن تنجح ظاهرياً وتفشل فعلياً، فلا تحكم على أي خطوة برسالة السكربت، وإنما بالدخول الفعلي وبطلب البيانات من خارج التطبيق.
تدريب عملي
- شغل محاكي Firebase بمشروع يبدأ ب
demo-، وأنشئ فيه مجموعة لها مجموعة فرعية، ثم شغلfirestore2jsonعليها، ولاحظ ما الذي لم يخرج، ثم اكتب خطافاً Hook يخرج المجموعة الفرعية. - شغل سكربت الهاش على مثال README الرسمي، ثم غير معاملاً واحداً، كفاصل الملح، ولاحظ أن الناتج تغير بالكامل، فهذا ما يحدث لكل مستخدميك إذا أخطأت في معامل واحد.
- استورد مستخدماً واحداً إلى Supabase أو Appwrite بهاشه، وادخل بكلمة مروره، ثم افحص الهاش المحفوظ بعد الدخول، وقارن ما تراه بما رأيناه في المقال.
- اكتب سياسة RLS تقابل قاعدة
get()في عناصر الطلب، واختبرها بمستخدمين.
وأهم هذه التمارين الثاني، لأنه يريك بعينك لماذا نصرنا على اختبار مستخدم واحد قبل استيراد الجميع: تغيير بايت واحد في معاملات المشروع يغير الهاش كله، ولا توجد رسالة خطأ تقول لك أي معامل أخطأت فيه، وإنما دخول يفشل فقط. ولذلك احفظ معاملات المشروع كما نسختها من لوحة Firebase في ملف واحد مع تاريخ النسخ، ولا تعد كتابتها يدوياً في أكثر من مكان، فأخطاء النسخ اليدوي لقيم base64 الطويلة أشيع مما تتوقع.
حذف المختبر
حذفنا Containers المحاكي والأنظمة الثلاثة وال Volumes والشبكات وال Images التي نزلناها بأسمائها، وحذفنا ملفات المستخدمين والهاش من الأجهزة التي عملنا عليها، ولا تقم بتشغيل docker system prune على سيرفر عليه خدمات أخرى.
وإذا كان الانتقال على سيرفر إنتاج، فاحذف ملفات التصدير من مجلد العمل قبل أي نسخة احتياطية للسيرفر، والسبب أن النسخة الاحتياطية ستحفظ ملف المستخدمين ومعاملات الهاش سنوات بعد أن تنسى أنهما كانا هناك.
الخلاصة
وصلنا لنهاية الموضوع، وأهم ما فيه:
- المحاكي الرسمي يعمل دون حساب Google بمشروع اسمه يبدأ ب
demo-، لكن تصديره فيه كلمات مرور واضحة وملف Firestore ثنائي، فالبيانات تقرأ عبر Admin SDK والهاش يحسب بالخوارزمية المنشورة. - هاش Firebase هو مفتاح توقيع المشروع مشفراً بمفتاح scrypt مشتق من كلمة المرور، فالنظام الجديد يحتاج معاملات المشروع الأربعة مع هاش كل مستخدم وملحه.
- Supabase يقبل الهاش منذ v2.162.0 بصيغة
$fbscrypt$حيثnهو mem_cost، ويبقيه بعد الدخول، والمعرف الجديد UUID. - Appwrite يقبله عبر Scrypt Modified ويحتفظ بمعرف Firebase نفسه، ويعيد الحساب ب argon2 بعد أول دخول.
- PocketBase لا يقبله، فالطريق استعادة كلمة المرور، ومعها SMTP مضبوط.
- البيانات تحتاج كوداً للمجموعات الفرعية والتواريخ والمراجع وإعادة ربط المالك، والقواعد تعاد كتابتها وتختبر، والجداول المستوردة تغلق قبل أي شيء.
دليلما هو Backend as a Service؟ وما بديل كل خدمة في Firebaseما الذي يقدمه ال Backend الجاهز لتطبيقك، ولماذا تصبح قواعد الوصول هي الحارس الوحيد لبياناتك، وما البديل المفتوح لكل خدمة في Firebase.
دليلSupabase على سيرفرك: بديل Firebase فوق PostgreSQLكيف تثبت Supabase على سيرفرك وتبني عليه تطبيقاً صغيراً بمستخدمين وصلاحيات وملفات، وما الذي ينقص النسخة المستضافة عن السحابية.
دليلAppwrite على سيرفرك: Backend متكامل للويب والجوالكيف تثبت Appwrite على سيرفرك وتبني عليه جدولاً بصلاحيات على مستوى الصف ومجلد ملفات ودالة وتطبيق ويب، وما الثمن الحقيقي بالذاكرة والقرص.
دليلPocketBase: Backend كامل في ملف واحد على سيرفرككيف تشغل PocketBase على سيرفرك وتبني عليه تطبيقاً بمستخدمين وقواعد وصول وملفات وتحديث فوري، وما الذي يكفيه سيرفر واحد وما الذي لا يكفيه.
دليلSupabase أم Appwrite أم PocketBase؟ مقارنة بالأرقامبنينا التطبيق نفسه على الأدوات الثلاث وقسنا الذاكرة والقرص والزمن والصلاحيات، لتختار الخلفية التي تناسب سيرفرك وفريقك.
دليلإشعارات Push بدون Firebase: ما يستبدل وما يبقى عند Appleما الذي تستطيع أن تخرج منه Firebase في إشعارات الويب وAndroid وiPhone، مع مختبر يرسل Web Push بمفاتيحك وUnifiedPush عبر ntfy على سيرفرك.سجل التحديثات
- 20 نوفمبر 2026: كتابة المقال، وتنفيذ المختبر على firebase-tools 15.37.0 ومحاكي Firestore 1.22.0 مع OpenJDK 21، وأدوات firebase-to-supabase، وSupabase self-hosted v0.8.2 مع GoTrue v2.196.0، وAppwrite 2.7.4 مع node-appwrite 32.0.0، وPocketBase v0.42.3.