ampatspell / ember-cli-zuglet

🔥 Easiest way to use Google Firebase services in your Ember.js Octane app

ember-cli-zuglet

This addon is dead simple way to use Google Firebase services in your Ember.js apps. Cloud Firestore, Storage, Auth, Functions.

ember-cli-zuglet is built and maintained by Arnis Vuskans, contact me for Ember.js, ember-cli-zuglet and Google Firebase consulting.

ember-cli-zuglet@^2.0.0 is a complete rewrite for Ember.js Octane edition.

• Website
• Documentation

Open source apps built using ember-cli-zuglet:

• kaste
• dzeja
• Pre-octane Ember.js & ember-cli-zuglet v1.x
  • tiny
  • bain ×
  • index65
  • ohne-zeit

Install

$ ember new foof --skip-npm

"devDependencies": {
-    "ember-data": "~3.22.0",
}

$ ember install ember-cli-zuglet

Open app/store.js and add your Firebase config.

Documentation

See the ember-cli-zuglet website for documentation and dummy app for examples.

Tweaks

// jsconfig.json
{
  "compilerOptions": {
    "target": "es6",
    "experimentalDecorators": true
  },
  "exclude": [ "node_modules", ".git" ]
}

Other useful addons to install

$ ember install tracked-toolbox
$ ember install macro-decorators

ember-cli-zuglet's Issues

Update storage API

• deprecate storage ref.child in favor of ref.ref
• add toStringExtension to storage refs

Finalize `less-experimental`, move it to `lifecycle`

Nested collection reference has wrong parent

store.doc('ducks/yellow').collection('foo/bar/baz')

_internal.ref is correct but string is ducks/yellow/baz

add `query.reload()` to align with `doc.reload()`

doc: guides/install

Fastboot shoebox support

• Queries and doc loads can be identified identified
• query() and doc.load() can have a fastboot configuration (cache in memory, in rtdb and so on)
• all the loaded documents and query states are put in shoebox (all?)
• in client there are now three sources -- cached, server and shoebox/fastboot

Update Firebase to SDK 5.8.0

add store.doc.delete

await store.doc('pdfs/one`).delete({ optional: true });

Unittest and document `doc.save({ token: true })`

Route models are not destroyed if `prepare` hook redirects

Do document updates with `{ merge: true }` and `FieldValue.delete`

Add support for mixins in inline models (route and standalone)

model().inline(RandomMixin, { 
  prepare() {
  }
})

add `store.models`

• factoryFor(name)
• create(name, props)
• consider exposing generated models

store.models.generate('foo', Mixin, {}); // throws if exists
store.models.factoryFor('foo') // proxy or null
store.models.create('foo', { ok: true });

add `doc.observer().until(..)`

await doc.observer().until('data.status', 'exists', doc => {
  return doc.exists && doc.get('data.status') !== 'pending';
}, 1000);

• resolves with doc when last arg returns true
• rejects on timeout (if provided)
• after resolve/reject observer is cancelled

`observed().owner('one', 'two')` should not recreate content twice

document observers.promise should optionally reject

// order: observed()
let order = this.store.doc(`orders/${order_id}`).existing();
this.setProperties({ order });
await order.observers.promise;

• this behavior should be configurable (optional: true)
• should reject if document was not found

Add `doc()` for document references

let pdf = store.collection(`pdfs`).doc();
let page = pdf.doc(`pages/${number}`);

Remove deprecated `doc` and `query` properties from Observer

• remove deprecated properties
• unify public model implementation (keep 2 container registrations)

Optimize data array deserialize

Right now if array has any changes, array content is replaced which forces models() content to be recreated.

Instead of that do separate adds and removes.

In addition to deserialize, replaceModelValues does basically the same.

Use Firebase Timestamp instead of Date in data timestamp internally

Model lifecycle should not require mapping for named models w/o prepare

templates: model().named('templates/book-cover').mapping(() => ({}))

Improve storage reference metadata and url API

it should be separate from reference itself.

Nested doc reference has wrong parent

store.collection('ducks').doc('yellow/feathers/asd')

_internal.ref is correct but string is ducks/asd

Query observer does not update individual document metadata

Observed documents stay with fromCache: true

add support for collection group queries

Upgrade Firebase SDK 5.4.0

get({source: 'cache'}): https://firebase.google.com/docs/reference/js/firebase.firestore.GetOptions

Unify observer.doc and observer.query as observer.content

let doc = this.store.doc('ducks/yellow').existing();
let observer = doc.observe();
observer.content //  => doc

let query = this.store.collection('ducks').query();
let observer = query.observe();
observer.content //  => query

• move props
• deprecate doc and query

`observed()` should support arrays

Observed should support arrays

feathers: observed().owner('duck').content(owner => {
  let ids = owner.duck.data.get('feathers');
  return ids.map(id => this.store.doc(`feathers/${id}`).existing());
  // returns array of documents which needs to be observed
  // all(this.feathers.map(doc => doc.observers.promise)) -- to resolve
}),

Also observer-for and resolve-observers should be aware of this

Deprecate `less-experimental` in favour of `lifecycle`

dependencies and factory fn for observed computed property

model computed property should allow to dynamically resolve model name

Implement `reusable()` for `model` and `models`

If model is reusable, it is not recreated, only prepare is called with new values

if reusable is a function:

model().owner('foo', 'bar').named('thing').reusable((owner, prev) => {
  let { foo, bar } = prev;
  return true;
});

Implement firebase.firestore.GetOptions for refs, docs and queries

• document reference
• document
• queryable load and first (collection ref and query ref)
• query

https://firebase.google.com/docs/reference/js/firebase.firestore.GetOptions

Update storage.ref.metadata and url after ref.delete

Right now metadata stays with isExisting: true

model array computed property

batch operations should return document

let doc = batch.save(ref.new({ ok: true }));

Remove deprecated `experimental` module

Remove deprecated `reference` from `storage/reference/metadata`

Update Firebase to SDK 5.3.1

doc: lifecycle section

Add store.auth.settle()

Remove deprecated `ember-cli-zuglet/register`

`models(...).owner('one', 'two')` should not recreate model twice

doc: guides/overview

add missing data serializer isDirty impls

• array
• reference

store.ready and settle test helper

something like this:

hooks.beforeEach(async function() {
  let store = this.owner.lookup('service:store');
  return store.ready;
});

Unittest and document `query({ doc: fn })`

Or maybe just add notion of identity for queries

Implement missing serializer.isDirty for timestamp

Clean up storage.metadata.reference API

• rename to ref
• move to reference/base so that it is available also for url model

Looks like data array adds/removes are not notifying or models are not picking it up

_adjustments: readOnly('doc.data.adjustments'),
models: models('_adjustments').named(data => `sketch/stage/node/adjustments/${data.get('type')}`).mapping((data, adjustments) => ({ data, adjustments })),

doc has changes, models are not reflecting those. seems like can't exactly observe proxy or something.