2 |
--------------------------------------------------------------------------------
/tests/dummy/app/templates/playground.hbs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/addon/-private/model/state/model.js:
--------------------------------------------------------------------------------
1 | import State from './state';
2 |
3 | export default class ModelState extends State {
4 | }
5 |
--------------------------------------------------------------------------------
/addon/-private/util/delay.js:
--------------------------------------------------------------------------------
1 | export const delay = (delay=1000) => new Promise(resolve => setTimeout(() => resolve(), delay));
2 |
--------------------------------------------------------------------------------
/config/environment.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = function(/* environment, appConfig */) {
4 | return { };
5 | };
6 |
--------------------------------------------------------------------------------
/firebase/cors.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "origin": [ "*" ],
4 | "method": [ "GET" ],
5 | "maxAgeSeconds": 3600
6 | }
7 | ]
8 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/stalled.hbs:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/tests/dummy/app/templates/playground/messages/message/index.hbs:
--------------------------------------------------------------------------------
1 | Still working…
3 |
2 |
3 |
--------------------------------------------------------------------------------
/addon/-private/model/decorators/root.js:
--------------------------------------------------------------------------------
1 | import { setRoot } from '../state';
2 |
3 | export const root = () => Class => setRoot(Class);
4 |
--------------------------------------------------------------------------------
/firebase/.firebaserc:
--------------------------------------------------------------------------------
1 | {
2 | "projects": {
3 | "default": "ember-cli-zuglet",
4 | "travis": "ember-cli-zuglet-travis"
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/fancy-message.js:
--------------------------------------------------------------------------------
1 | import Message from './message';
2 |
3 | export default class FancyMessage extends Message {
4 | }
5 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/route/docs-page-index.scss:
--------------------------------------------------------------------------------
1 | .route-docs-page-index {
2 | > .placeholder {
3 | padding: 15px 0;
4 | }
5 | }
6 |
--------------------------------------------------------------------------------
/addon/components/zuglet/stalled.hbs:
--------------------------------------------------------------------------------
1 | {{#let this.stalledPromises as |stats|}}
2 | {{#if stats}}
3 | {{yield stats}}
4 | {{/if}}
5 | {{/let}}
--------------------------------------------------------------------------------
/docs/api/auth/methods/popup.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Popup
3 | pos: 3
4 | ---
5 |
6 | # Popup
7 |
8 | ## google
9 |
10 | Google accounts
11 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/remark/link-to.hbs:
--------------------------------------------------------------------------------
1 | {{@content}}
--------------------------------------------------------------------------------
/tests/dummy/app/templates/playground/messages.hbs:
--------------------------------------------------------------------------------
1 |
2 | {{@page.title}}
3 |
4 |
--------------------------------------------------------------------------------
/addon/-private/model/properties/property/index.js:
--------------------------------------------------------------------------------
1 | import Property from './property';
2 | import { property } from './decorator';
3 |
4 | export {
5 | property
6 | }
7 |
8 | export default Property;
9 |
--------------------------------------------------------------------------------
/addon/-private/util/snapshot.js:
--------------------------------------------------------------------------------
1 | export const snapshotToDeferredType = snapshot => {
2 | let { fromCache } = snapshot.metadata;
3 | if(fromCache) {
4 | return 'cached';
5 | }
6 | return 'remote';
7 | }
8 |
--------------------------------------------------------------------------------
/addon/-private/util/to-json.js:
--------------------------------------------------------------------------------
1 | import { toPrimitive } from './to-primitive';
2 |
3 | export const toJSON = (instance, props) => {
4 | return {
5 | instance: toPrimitive(instance),
6 | ...props
7 | };
8 | };
9 |
--------------------------------------------------------------------------------
/tests/dummy/config/optional-features.json:
--------------------------------------------------------------------------------
1 | {
2 | "application-template-wrapper": false,
3 | "default-async-observers": true,
4 | "jquery-integration": false,
5 | "template-only-glimmer-components": true
6 | }
7 |
--------------------------------------------------------------------------------
/tests/helpers/setup-helpers.js:
--------------------------------------------------------------------------------
1 | export const setupHelpers = hooks => {
2 | hooks.beforeEach(function() {
3 | this.registerModel = (name, factory) => this.owner.register(`model:${name}`, factory);
4 | });
5 | }
6 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/toc/pages.hbs:
--------------------------------------------------------------------------------
1 |
2 | {{#each @pages as |nested|}}
3 | {{#unless nested.hidden}}
4 |
5 | {{/unless}}
6 | {{/each}}
7 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/index/section.hbs:
--------------------------------------------------------------------------------
1 |
2 |
9 |
--------------------------------------------------------------------------------
/docs/index/what.md:
--------------------------------------------------------------------------------
1 | ember-cli-zuglet is an [Ember.js](https://emberjs.com/) Octane Edition addon that lets you build complex apps with [Google Firebase](http://firebase.google.com) Firestore, Auth, Storage and Functions easy and fun.
2 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/docs.hbs:
--------------------------------------------------------------------------------
1 |
3 | {{@aside}}
4 |
5 |
6 | {{yield}}
7 |
8 |
2 |
--------------------------------------------------------------------------------
/tests/dummy/config/targets.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const browsers = [
4 | 'last 1 Chrome versions',
5 | 'last 1 Firefox versions',
6 | 'last 1 Safari versions',
7 | ];
8 |
9 | module.exports = {
10 | browsers
11 | };
12 |
--------------------------------------------------------------------------------
/.template-lintrc.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = {
4 | extends: 'recommended',
5 | rules: {
6 | 'no-index-component-invocation': false,
7 | 'require-input-label': false,
8 | 'no-yield-only': false
9 | }
10 | };
11 |
--------------------------------------------------------------------------------
/docs/api/firestore.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Firestore
3 | pos: 3
4 | ---
5 |
6 | # Firestore
7 |
8 | * [Store](api/store)
9 | * [References](api/firestore/reference)
10 | * [Document](api/firestore/document)
11 | * [Query](api/firestore/query)
12 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/master-detail.hbs:
--------------------------------------------------------------------------------
1 | Page /{{@path}} was not found
3 |
4 | ← back to index
5 |
6 |
2 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/toc.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { inject as service } from '@ember/service';
3 |
4 | export default class BlockTocComponent extends Component {
5 |
6 | @service config;
7 |
8 | }
9 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/hljs/index.scss:
--------------------------------------------------------------------------------
1 | @import "tomorrow";
2 |
3 | .hljs {
4 | font-family: $font-code;
5 | padding: 0;
6 | border: 1px solid fade-out(#000, 0.9);
7 | border-radius: 3px;
8 | padding: 9px 10px 8px 10px;
9 | }
10 |
--------------------------------------------------------------------------------
/addon/-private/util/to-string.js:
--------------------------------------------------------------------------------
1 | import { toPrimitive } from './to-primitive';
2 |
3 | export const toString = (model, string) => {
4 | if(!model) {
5 | return;
6 | }
7 | return `<${toPrimitive(model)}${string ? `:${string}` : ''}>`;
8 | };
9 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/docs/page/index.hbs:
--------------------------------------------------------------------------------
1 |
3 | {{yield (hash isMaster=true)}}
4 |
5 |
6 | {{yield (hash isDetail=true)}}
7 |
8 |
2 | {{#if @page}}
3 |
4 | {{else}}
5 |
--------------------------------------------------------------------------------
/blueprints/ember-cli-zuglet/index.js:
--------------------------------------------------------------------------------
1 | /* eslint-env node */
2 | 'use strict';
3 |
4 | module.exports = {
5 | normalizeEntityName() {
6 | },
7 | fileMapTokens() {
8 | return {
9 | __root__: () => '/app'
10 | };
11 | }
12 | };
13 |
--------------------------------------------------------------------------------
/blueprints/ember-cli-zuglet/files/__root__/models/user.js:
--------------------------------------------------------------------------------
1 | import User from 'zuglet/user';
2 |
3 | export default class <%= classifiedPackageName %>User extends User {
4 |
5 | async restore(user) {
6 | await super.restore(user);
7 | }
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/docs/api/firestore/reference.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Reference
3 | pos: 0
4 | ---
5 |
6 | # Reference
7 |
8 | * [Document](api/firestore/reference/document)
9 | * [Queryable](api/firestore/reference/queryable) & [Collection](api/firestore/reference/collection)
10 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/index.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { inject as service } from '@ember/service';
3 |
4 | export default class RouteIndexComponent extends Component {
5 |
6 | @service
7 | config
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/addon/-private/store/auth/methods/method.js:
--------------------------------------------------------------------------------
1 | import ZugletObject from '../../../object';
2 |
3 | export default class AuthMethod extends ZugletObject {
4 |
5 | constructor(owner, { auth }) {
6 | super(owner);
7 | this.auth = auth;
8 | }
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/addon/-private/util/model-factory.js:
--------------------------------------------------------------------------------
1 | const MODELS = new WeakMap();
2 |
3 | export const registerModel = (model, modelName) => {
4 | MODELS.set(model, { modelName });
5 | return model;
6 | };
7 |
8 | export const getModelName = model => MODELS.get(model)?.modelName;
9 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/user.js:
--------------------------------------------------------------------------------
1 | import User from 'zuglet/user';
2 |
3 | export default class DummyUser extends User {
4 |
5 | async restore(user /*, details*/) {
6 | await super.restore(user);
7 | // console.log(this.uid, details);
8 | }
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/server/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = app => {
4 | let express = require('express'); // eslint-disable-line node/no-extraneous-require
5 | let path = require('path');
6 | app.use('/coverage', express.static(path.join(__dirname, '..', 'coverage')));
7 | };
8 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/docs.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 |
4 | export default class DocsRoute extends Route {
5 |
6 | @service docs;
7 |
8 | model() {
9 | return this.docs;
10 | }
11 |
12 | }
13 |
--------------------------------------------------------------------------------
/firebase/functions/index.js:
--------------------------------------------------------------------------------
1 | const functions = require('firebase-functions');
2 |
3 | module.exports.echo = functions.https.onCall((data, context) => {
4 | let { auth } = context;
5 | let uid;
6 | if(auth) {
7 | uid = auth.uid;
8 | }
9 | return { data, uid };
10 | });
11 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/query/single.hbs:
--------------------------------------------------------------------------------
1 | Page "{{@id}}" was not found
6 | {{/if}}
7 |
2 |
3 |
--------------------------------------------------------------------------------
/docs/api/auth/methods.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Methods
3 | pos: 1
4 | ---
5 |
6 | # Methods
7 |
8 | ## anonymous
9 |
10 | anonymous accounts
11 |
12 | ## email
13 |
14 | email-based accounts
15 |
16 | ## token
17 |
18 | sign in with custom token
19 |
20 | ## popup
21 |
22 | popup-based sign-in
23 |
--------------------------------------------------------------------------------
/docs/api/auth/methods/anonymous.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Anonymous
3 | pos: 0
4 | ---
5 |
6 | # Anonymous
7 |
8 | ## async signIn() `→ User`
9 |
10 | Sign-in anonymously
11 |
12 | ``` javascript
13 | let user = await store.auth.methods.anonymous.signIn();
14 | store.auth.user === user // → true
15 | ```
16 |
--------------------------------------------------------------------------------
/docs/api/auth/methods/token.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Token
3 | pos: 2
4 | ---
5 |
6 | # Token
7 |
8 | ## async signIn(token) `→ User`
9 |
10 | Sign-in with custom token
11 |
12 | ``` javascript
13 | let user = await store.auth.methods.token.signIn(token);
14 | store.auth.user === user // → true
15 | ```
16 |
--------------------------------------------------------------------------------
/addon/-private/util/array.js:
--------------------------------------------------------------------------------
1 | export const removeAt = (array, index) => {
2 | if(index > -1) {
3 | array.splice(index, 1);
4 | }
5 | return array;
6 | }
7 |
8 | export const removeObject = (array, object) => {
9 | let index = array.indexOf(object);
10 | return removeAt(array, index);
11 | }
12 |
--------------------------------------------------------------------------------
/docs/api.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: API
3 | pos: 4
4 | ---
5 |
6 | # API Documentation
7 |
8 | ## Exports
9 |
10 | ``` javascript
11 | import { initialize } from 'zuglet/initialize';
12 | import ZugletObject from 'zuglet/object';
13 | import Store from 'zuglet/store';
14 | import User from 'zuglet/user';
15 | ```
16 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/json.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { objectToJSON } from 'zuglet/utils';
3 |
4 | export default class JsonComponent extends Component {
5 |
6 | get string() {
7 | return JSON.stringify(objectToJSON(this.args.value), null, 2);
8 | }
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/docs/index.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 |
4 | export default class DocsIndexRoute extends Route {
5 |
6 | @service docs;
7 |
8 | model() {
9 | return this.docs.page('docs').load();
10 | }
11 |
12 | }
13 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/route.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { action } from '@ember/object';
3 |
4 | export default class RouteRouteComponent extends Component {
5 |
6 | @action
7 | async add() {
8 | await this.args.model.add('Untitled');
9 | }
10 |
11 | }
12 |
--------------------------------------------------------------------------------
/.ember-cli:
--------------------------------------------------------------------------------
1 | {
2 | /**
3 | Ember CLI sends analytics information by default. The data is completely
4 | anonymous, but there are times when you might want to disable this behavior.
5 |
6 | Setting `disableAnalytics` to true will prevent any data from being sent.
7 | */
8 | "disableAnalytics": false
9 | }
10 |
--------------------------------------------------------------------------------
/firebase/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "firebase",
3 | "version": "1.0.0",
4 | "description": "",
5 | "main": "index.js",
6 | "scripts": {
7 | "emulators": "firebase emulators:start --import ./export --export-on-exit ./export"
8 | },
9 | "keywords": [],
10 | "author": "",
11 | "license": "ISC"
12 | }
13 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/docs/route.hbs:
--------------------------------------------------------------------------------
1 | {{~#if @node.properties.model~}}
2 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
2 | {{#if this.file}}
3 |
4 | {{else}}
5 |
6 | {{/if}}
7 |
8 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/dev.hbs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/route.hbs:
--------------------------------------------------------------------------------
1 |
4 | {{this}}
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
2 |
3 |
9 | {{/each}}
10 |
11 |
--------------------------------------------------------------------------------
/docs/api/firestore/reference/condition.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Condition
3 | pos: 5
4 | ---
5 |
6 | # Condition Reference `extends QueryableReference`
7 |
8 | See [Queryable Reference](api/firestore/reference/queryable) for query `load`, `query` and condition methods which are shared between `Collection`, `CollectionGroup` and `Condition` references.
9 |
--------------------------------------------------------------------------------
/addon/-private/util/to-primitive.js:
--------------------------------------------------------------------------------
1 | import { guidFor } from '@ember/object/internals';
2 | import { getModelName } from './model-factory';
3 |
4 | export const toPrimitive = model => {
5 | if(!model) {
6 | return;
7 | }
8 | let name = getModelName(model) || model.constructor.name;
9 | return `${name}::${guidFor(model)}`;
10 | };
11 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/messages/message/index.hbs:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/addon/-private/util/date.js:
--------------------------------------------------------------------------------
1 | let _dateTimeFormatter = new Intl.DateTimeFormat('default', {
2 | year: 'numeric',
3 | month: 'numeric',
4 | day: 'numeric',
5 | hour: 'numeric',
6 | minute: 'numeric',
7 | seconds: 'numeric',
8 | timeZoneName: 'short'
9 | });
10 |
11 | export const formatDate = value => _dateTimeFormatter.format(value);
12 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/changes/property.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { action } from '@ember/object';
3 |
4 | export default class BlockChangesPropertyComponent extends Component {
5 |
6 | @action
7 | onValue(_, [ value ]) {
8 | this.args.onPropertyChange(this.args.key, value);
9 | }
10 |
11 | }
12 |
--------------------------------------------------------------------------------
/docs/decorators.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Decorators
3 | pos: 3
4 | ---
5 |
6 | # Decorators
7 |
8 | Decorators are used to compose overall architecture for apps built using `ember-cli-zuglet`.
9 |
10 | ## Exports
11 |
12 | ``` javascript
13 | import {
14 | route,
15 | root,
16 | activate,
17 | model,
18 | models
19 | } from 'zuglet/decorators';
20 | ```
21 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground.hbs:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 | {{#each @model.models as |model|}}
8 |
2 |
10 |
11 |
4 | {{yield}}
5 |
6 |
7 |
8 |
9 |
2 |
3 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/changes.hbs:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
2 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/pages/messages/message/index.js:
--------------------------------------------------------------------------------
1 | import ZugletObject from 'zuglet/object';
2 |
3 | export default class PagesMessagesMessageIndex extends ZugletObject {
4 |
5 | constructor(owner, { message }) {
6 | super(owner);
7 | this.message = message;
8 | }
9 |
10 | async load() {
11 | return await this.message.load();
12 | }
13 |
14 | }
15 |
--------------------------------------------------------------------------------
/docs/api/auth/methods/popup/google.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Google
3 | pos: 0
4 | ---
5 |
6 | # Google
7 |
8 | ## async signIn(scopes) `→ User`
9 |
10 | Sign-in using Google account.
11 |
12 | * `scopes` → defaults to `[ 'profile', 'email' ]`
13 |
14 | ``` javascript
15 | let user = await store.auth.methods.popup.google.signIn();
16 | store.auth.user === user // → true
17 | ```
18 |
--------------------------------------------------------------------------------
/tests/test-helper.js:
--------------------------------------------------------------------------------
1 | import Application from 'dummy/app';
2 | import config from 'dummy/config/environment';
3 | import * as QUnit from 'qunit';
4 | import { setApplication } from '@ember/test-helpers';
5 | import { setup } from 'qunit-dom';
6 | import { start } from 'ember-qunit';
7 |
8 | setApplication(Application.create(config.APP));
9 |
10 | setup(QUnit.assert);
11 |
12 | start();
13 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/message.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { action } from '@ember/object';
3 |
4 | export default class BlockMessageComponent extends Component {
5 |
6 | @action
7 | async save() {
8 | await this.args.message.save();
9 | }
10 |
11 | @action
12 | async delete() {
13 | await this.args.message.delete();
14 | }
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/query/array.hbs:
--------------------------------------------------------------------------------
1 | {{this.log}}
3 | {{#unless this.log}}
4 | No events
5 | {{/unless}}
6 | {{yield (hash
7 | Property=(component 'block/changes/property' onPropertyChange=this.onPropertyChange)
8 | )}}
9 |
2 |
3 |
--------------------------------------------------------------------------------
/addon/-private/store/auth/methods/popup.js:
--------------------------------------------------------------------------------
1 | import AuthMethod from './method';
2 | import { cached } from '../../../model/decorators/cached';
3 |
4 | export default class AuthPopupMethod extends AuthMethod {
5 |
6 | _method(name) {
7 | return this.auth.methods._method(`popup/${name}`);
8 | }
9 |
10 | @cached()
11 | get google() {
12 | return this._method('google');
13 | }
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/functions.hbs:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 | {{#each this.query.content as |doc|}}
8 |
9 |
10 |
11 | {{else}}
12 | Nothing here yet
13 | {{/each}}
14 |
15 |
2 |
3 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/content.hbs:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
2 |
3 |
14 | {{/each}}
15 |
16 |
--------------------------------------------------------------------------------
/addon/-private/util/set-global.js:
--------------------------------------------------------------------------------
1 | /* istanbul ignore next */
2 | export const setGlobal = (hash, silent=false) => {
3 | if(typeof window === 'undefined') {
4 | return;
5 | }
6 | for(let key in hash) {
7 | let value = hash[key];
8 | if(!silent) {
9 | // eslint-disable-next-line no-console
10 | console.log(`window.${key} = ${value}`);
11 | }
12 | window[key] = value;
13 | }
14 | };
15 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/app.scss:
--------------------------------------------------------------------------------
1 | @import url('https://fonts.googleapis.com/css2?family=Ubuntu+Mono:wght@400;700');
2 |
3 | $font-code: 'Ubuntu Mono';
4 | $font-text: 'Ubuntu Mono';
5 | $font-size: 14px;
6 | $font-size-smaller: 12px;
7 |
8 | @import "body";
9 | @import "breakpoints";
10 | @import "application";
11 | @import "playground";
12 | @import "remark";
13 | @import "route/index";
14 | @import "route/docs-page-index";
15 |
--------------------------------------------------------------------------------
/app/instance-initializers/zuglet-fastboot.js:
--------------------------------------------------------------------------------
1 | import { lookupFastBoot } from 'zuglet/-private/util/fastboot';
2 |
3 | export default {
4 | name: 'zuglet:fastboot',
5 | initialize(app) {
6 | let { fastboot, isFastBoot } = lookupFastBoot(app);
7 | /* istanbul ignore next */
8 | if(isFastBoot) {
9 | let stores = app.lookup('zuglet:stores');
10 | fastboot.deferRendering(stores.settle());
11 | }
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/firebase/storage.rules:
--------------------------------------------------------------------------------
1 | rules_version = '2';
2 | service firebase.storage {
3 | match /b/{bucket}/o {
4 |
5 | match /hello {
6 | allow read: if true;
7 | allow write: if true;
8 | }
9 |
10 | match /files/{file} {
11 | allow read: if true;
12 | allow write: if true;
13 | match /{nested} {
14 | allow read: if true;
15 | allow write: if true;
16 | }
17 | }
18 |
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/addon/-private/util/random-string.js:
--------------------------------------------------------------------------------
1 | // https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
2 |
3 | const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
4 |
5 | export const randomString = (len=8) => {
6 | let string = '';
7 | for(let i = 0; i < len; i++) {
8 | string += possible.charAt(Math.floor(Math.random() * possible.length));
9 | }
10 | return string;
11 | };
12 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/block/toc.hbs:
--------------------------------------------------------------------------------
1 |
4 |
11 |
12 | {{#each this.models as |model|}}
13 |
5 | {{this.query.string}}
6 |
7 |
8 |
9 |
10 |
2 |
8 |
--------------------------------------------------------------------------------
/addon/-private/store/auth/methods/anonymous.js:
--------------------------------------------------------------------------------
1 | import AuthMethod from './method';
2 | import { registerPromise } from '../../../stores/stats';
3 |
4 | export default class AnonymousAuthMethod extends AuthMethod {
5 |
6 | signIn() {
7 | return this.auth._withAuthReturningUser(async auth => {
8 | let { user } = await registerPromise(this, 'sign-in', true, auth.signInAnonymously());
9 | return { user };
10 | });
11 | }
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/tests/dummy/app/app.js:
--------------------------------------------------------------------------------
1 | import Application from '@ember/application';
2 | import Resolver from 'ember-resolver';
3 | import loadInitializers from 'ember-load-initializers';
4 | import config from 'dummy/config/environment';
5 |
6 | export default class App extends Application {
7 | modulePrefix = config.modulePrefix;
8 | podModulePrefix = config.podModulePrefix;
9 | Resolver = Resolver;
10 | }
11 |
12 | loadInitializers(App, config.modulePrefix);
13 |
--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
1 | # EditorConfig helps developers define and maintain consistent
2 | # coding styles between different editors and IDEs
3 | # editorconfig.org
4 |
5 | root = true
6 |
7 | [*]
8 | end_of_line = lf
9 | charset = utf-8
10 | trim_trailing_whitespace = true
11 | insert_final_newline = true
12 | indent_style = space
13 | indent_size = 2
14 |
15 | [*.hbs]
16 | insert_final_newline = false
17 |
18 | [*.{diff,md}]
19 | trim_trailing_whitespace = false
20 |
--------------------------------------------------------------------------------
/addon/-private/store/auth/methods/token.js:
--------------------------------------------------------------------------------
1 | import AuthMethod from './method';
2 | import { registerPromise } from '../../../stores/stats';
3 |
4 | export default class TokenAuthMethod extends AuthMethod {
5 |
6 | signIn(token) {
7 | return this.auth._withAuthReturningUser(async auth => {
8 | let { user } = await registerPromise(this, 'sign-in', true, auth.signInWithCustomToken(token));
9 | return { user };
10 | });
11 | }
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/playground/messages.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 | import { route } from 'zuglet/decorators';
4 |
5 | @route()
6 | export default class MessagesRoute extends Route {
7 |
8 | @service
9 | store
10 |
11 | model() {
12 | return this.store.models.create('messages');
13 | }
14 |
15 | async load(model) {
16 | await model.load();
17 | }
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | # unconventional js
2 | /blueprints/*/files/
3 | /vendor/
4 |
5 | # compiled output
6 | /dist/
7 | /tmp/
8 |
9 | # dependencies
10 | /bower_components/
11 | /node_modules/
12 |
13 | # misc
14 | /coverage/
15 | !.*
16 | .eslintcache
17 | .lint-todo/
18 |
19 | # ember-try
20 | /.node_modules.ember-try/
21 | /bower.json.ember-try
22 | /npm-shrinkwrap.json.ember-try
23 | /package.json.ember-try
24 | /package-lock.json.ember-try
25 | /yarn.lock.ember-try
26 |
--------------------------------------------------------------------------------
/blueprints/ember-cli-zuglet/files/__root__/routes/application.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 | import { route } from 'zuglet/decorators';
4 | import { load } from 'zuglet/utils';
5 |
6 | @route()
7 | export default class ApplicationRoute extends Route {
8 |
9 | @service
10 | store
11 |
12 | model() {
13 | }
14 |
15 | async load() {
16 | await load(this.store.auth);
17 | }
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/tests/dummy/config/ember-cli-update.json:
--------------------------------------------------------------------------------
1 | {
2 | "schemaVersion": "1.0.0",
3 | "packages": [
4 | {
5 | "name": "ember-cli",
6 | "version": "4.2.0",
7 | "blueprints": [
8 | {
9 | "name": "addon",
10 | "outputRepo": "https://github.com/ember-cli/ember-addon-output",
11 | "codemodsSource": "ember-addon-codemods-manifest@1",
12 | "isBaseBlueprint": true
13 | }
14 | ]
15 | }
16 | ]
17 | }
18 |
--------------------------------------------------------------------------------
/addon/-private/model/state/root.js:
--------------------------------------------------------------------------------
1 | import State from './state';
2 | import { registerDestructor } from '@ember/destroyable';
3 |
4 | export default class RootState extends State {
5 |
6 | constructor() {
7 | super(...arguments);
8 | registerDestructor(this.owner, () => this._onOwnerWillDestroy());
9 | }
10 |
11 | didCreateState() {
12 | this.activate(this);
13 | }
14 |
15 | _onOwnerWillDestroy() {
16 | this.deactivate(this);
17 | }
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/docs/page.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 |
4 | export default class DocsPageRoute extends Route {
5 |
6 | @service docs;
7 |
8 | async model({ page_id: id }) {
9 | if(id === 'index') {
10 | return this.transitionTo('index');
11 | }
12 | let page = await this.docs.page(id)?.load();
13 | return {
14 | id,
15 | page
16 | };
17 | }
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/addon/-private/store/firebase.js:
--------------------------------------------------------------------------------
1 | import firebase from "firebase/compat/app";
2 |
3 | let id = 0;
4 |
5 | export const initializeApp = (config, name) => firebase.initializeApp(config, `${name}-${id++}`);
6 | export const destroyApp = app => app.delete();
7 |
8 | export const enablePersistence = async firestore => {
9 | await firestore.enablePersistence({ synchronizeTabs: true }).catch(err => {
10 | console.error('firestore/enable-persistence', err.stack);
11 | });
12 | };
13 |
--------------------------------------------------------------------------------
/addon/-private/util/get-owner.js:
--------------------------------------------------------------------------------
1 | import { getOwner as emberGetOwner } from '@ember/application';
2 | import { assert } from '@ember/debug';
3 |
4 | const {
5 | assign
6 | } = Object;
7 |
8 | export const getOwner = (object, opts) => {
9 | let { optional } = assign({ optional: false }, opts);
10 | assert(`object is required`, !!object);
11 | let owner = emberGetOwner(object);
12 | assert(`${object} must have Ember.js owner`, !!owner || optional);
13 | return owner;
14 | };
15 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/post.js:
--------------------------------------------------------------------------------
1 | import ZugletObject from 'zuglet/object';
2 | import { reads } from 'macro-decorators';
3 |
4 | const data = key => reads(`doc.data.${key}`);
5 |
6 | export default class Post extends ZugletObject {
7 |
8 | constructor(owner, { doc }) {
9 | super(owner);
10 | this.doc = doc;
11 | }
12 |
13 | @data('title') title;
14 | @data('position') position;
15 |
16 | load(type) {
17 | console.log('load', type, this+'');
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/docs/api/firestore/reference/collection-group.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Collection Group
3 | pos: 4
4 | ---
5 |
6 | # Collection Group Reference `extends QueryableReference`
7 |
8 | See [Queryable Reference](api/firestore/reference/queryable) for query `load`, `query` and condition methods which are shared between `Collection`, `CollectionGroup` and `Condition` references.
9 |
10 | ``` javascript
11 | let ref = store.group('messages');
12 | ```
13 |
14 | ## id `→ string`
15 |
16 | Collection id
17 |
--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | # unconventional js
2 | /blueprints/*/files/
3 | /vendor/
4 |
5 | # compiled output
6 | /dist/
7 | /tmp/
8 |
9 | # dependencies
10 | /bower_components/
11 | /node_modules/
12 |
13 | # misc
14 | /coverage/
15 | !.*
16 | .*/
17 | .eslintcache
18 |
19 | # ember-try
20 | /.node_modules.ember-try/
21 | /bower.json.ember-try
22 | /npm-shrinkwrap.json.ember-try
23 | /package.json.ember-try
24 | /package-lock.json.ember-try
25 | /yarn.lock.ember-try
26 |
27 | /firebase
28 | /jsconfig.json
29 |
--------------------------------------------------------------------------------
/addon/-private/model/properties/property/decorator.js:
--------------------------------------------------------------------------------
1 | import { getState } from '../../state';
2 | import { getFactory } from '../../../factory/get-factory';
3 |
4 | const createProperty = (state, owner, name, key, opts) => {
5 | return getFactory(owner).zuglet.create(`properties/${name}`, { state, owner, key, opts });
6 | }
7 |
8 | export const property = (owner, key, name, opts) => {
9 | return getState(owner).getProperty(key, state => createProperty(state, owner, name, key, opts));
10 | }
11 |
--------------------------------------------------------------------------------
/addon/-private/util/activate.js:
--------------------------------------------------------------------------------
1 | import { getState } from '../model/state';
2 |
3 | class Activator {
4 | toString() {
5 | return `
3 | {{this.config.name}} v{{this.config.version}}
4 | Documentation
6 |
7 | Firebase v{{this.config.firebase}}
5 |
2 |
3 |
14 | {{/each}}
15 |
16 |
--------------------------------------------------------------------------------
/tests/dummy/app/services/config.js:
--------------------------------------------------------------------------------
1 | import Service from '@ember/service';
2 | import environment from '../config/environment';
3 | import flags from 'zuglet/-private/flags';
4 |
5 | let {
6 | version: {
7 | zuglet: version,
8 | firebase
9 | }
10 | } = flags;
11 |
12 | let {
13 | dummy: {
14 | name
15 | }
16 | } = environment;
17 |
18 | export default class ConfigService extends Service {
19 |
20 | name = name;
21 | version = version;
22 | firebase = firebase;
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/addon/decorators.js:
--------------------------------------------------------------------------------
1 | import { root } from './-private/model/decorators/root';
2 | import { route } from './-private/model/decorators/route';
3 | import { activate } from './-private/model/properties/activate';
4 | import { object } from './-private/model/properties/object';
5 | import { models } from './-private/model/properties/models';
6 | import { model } from './-private/model/properties/model';
7 |
8 | export {
9 | root,
10 | route,
11 | activate,
12 | object,
13 | models,
14 | model
15 | };
16 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/index.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 | import { hash } from 'rsvp';
4 |
5 | export default class IndexRoute extends Route {
6 |
7 | @service
8 | docs
9 |
10 | async model() {
11 | let pages = await hash(this.docs.directory('index').reduce((hash, page) => {
12 | hash[page.name] = page.load();
13 | return hash;
14 | }, {}));
15 | return {
16 | pages
17 | };
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/playground/auth/email.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 |
4 | export default class MessagesRoute extends Route {
5 |
6 | @service store;
7 | @service router;
8 |
9 | async model({ email }) {
10 | try {
11 | await this.store.auth.methods.email.signInWithLink(email);
12 | } catch(err) {
13 | console.log(err);
14 | }
15 | this.router.transitionTo('playground.auth');
16 | }
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/addon/-private/util/fastboot.js:
--------------------------------------------------------------------------------
1 | import { getOwner } from '@ember/application';
2 |
3 | export const lookupFastBoot = owner => {
4 | let fastboot = owner.lookup('service:fastboot');
5 | let isFastBoot = fastboot && fastboot.isFastBoot;
6 | return {
7 | fastboot,
8 | isFastBoot
9 | };
10 | };
11 |
12 | export const getFastBoot = sender => lookupFastBoot(getOwner(sender));
13 |
14 | export const isFastBoot = sender => {
15 | let { isFastBoot } = getFastBoot(sender);
16 | return isFastBoot;
17 | };
18 |
--------------------------------------------------------------------------------
/docs/api/functions/region.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Region
3 | pos: 0
4 | ---
5 |
6 | # Region
7 |
8 | ## identifier `→ string`
9 |
10 | Region identifier
11 |
12 | ``` javascript
13 | let region = store.functions.region();
14 | region.identifier // → 'us-central1'
15 | ```
16 |
17 | ## async call(name, props) `→ object`
18 |
19 | Calls Firebase callable function.
20 |
21 | ``` javascript
22 | let region = store.functions.region();
23 | let result = await region.call('hello', { ok: true });
24 | result // → { data: { … } }
25 | ```
26 |
--------------------------------------------------------------------------------
/tests/dummy/app/routes/application.js:
--------------------------------------------------------------------------------
1 | import Route from '@ember/routing/route';
2 | import { inject as service } from '@ember/service';
3 | import { route } from 'zuglet/decorators';
4 |
5 | @route()
6 | export default class RouteRoute extends Route {
7 |
8 | @service store;
9 | @service docs;
10 |
11 | model() {
12 | }
13 |
14 | async load() {
15 | // resolve current user before rendering app
16 | await Promise.all([
17 | this.store.load(),
18 | this.docs.load()
19 | ]);
20 | }
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/addon/-private/store/firestore/references/condition.js:
--------------------------------------------------------------------------------
1 | import QueryableReference from './queryable';
2 |
3 | export default class ConditionReference extends QueryableReference {
4 |
5 | constructor(owner, opts) {
6 | super(owner, opts);
7 | let { string, parent } = opts;
8 | this.string = string;
9 | this.parent = parent;
10 | }
11 |
12 | get serialized() {
13 | let { string } = this;
14 | return { string };
15 | }
16 |
17 | toStringExtension() {
18 | return `${this.string}`;
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/app/initializers/zuglet-version.js:
--------------------------------------------------------------------------------
1 | import Ember from 'ember';
2 | import flags from 'zuglet/-private/flags';
3 |
4 | const {
5 | libraries
6 | } = Ember;
7 |
8 | const {
9 | version
10 | } = flags;
11 |
12 | let registered = false;
13 |
14 | export default {
15 | name: 'zuglet:version',
16 | initialize() {
17 | if(registered) {
18 | return;
19 | }
20 | registered = true;
21 | libraries.register('ember-cli-zuglet', version.zuglet);
22 | libraries.register('firebase', version.firebase);
23 | }
24 | };
25 |
--------------------------------------------------------------------------------
/tests/unit/auth-methods-popup-test.js:
--------------------------------------------------------------------------------
1 | import { module, test, setupStoreTest } from '../helpers/setup';
2 |
3 | module('auth / methods / popup', function(hooks) {
4 | setupStoreTest(hooks);
5 |
6 | hooks.beforeEach(async function() {
7 | this.auth = this.store.auth;
8 | });
9 |
10 | test('popup exists', async function(assert) {
11 | assert.ok(this.auth.methods.popup);
12 | });
13 |
14 | test('popup.google exists', async function(assert) {
15 | assert.ok(this.auth.methods.popup.google);
16 | });
17 |
18 | });
19 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/dev.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { inject as service } from '@ember/service';
3 | import { setGlobal, toString } from 'zuglet/utils';
4 | import { root } from 'zuglet/decorators';
5 |
6 | @root()
7 | export default class RouteDevComponent extends Component {
8 |
9 | @service
10 | store
11 |
12 | constructor() {
13 | super(...arguments);
14 | setGlobal({ component: this });
15 | }
16 |
17 | toString() {
18 | return toString(this);
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/index.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { inject as service } from '@ember/service';
3 | import { setGlobal, toString } from 'zuglet/utils';
4 | import { root } from 'zuglet/decorators';
5 |
6 | @root()
7 | export default class RouteIndexComponent extends Component {
8 |
9 | @service
10 | store
11 |
12 | constructor() {
13 | super(...arguments);
14 | setGlobal({ component: this });
15 | }
16 |
17 | toString() {
18 | return toString(this);
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/firebase/standalone/lib/create-token.js:
--------------------------------------------------------------------------------
1 | let { withContext, argv, exit } = require('./setup');
2 |
3 | let { project, uid } = argv;
4 | if(!project) {
5 | exit('--project=
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 | {{#each this.models as |model|}}
13 |
2 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/pages/messages/message.js:
--------------------------------------------------------------------------------
1 | import ZugletObject from 'zuglet/object';
2 | import { activate } from 'zuglet/decorators';
3 |
4 | export default class PagesMessagesMessage extends ZugletObject {
5 |
6 | @activate().content(({ messages, id }) => messages.byId(id))
7 | message;
8 |
9 | constructor(owner, { messages, id }) {
10 | super(owner);
11 | this.messages = messages;
12 | this.id = id;
13 | }
14 |
15 | async load() {
16 | let { message } = this;
17 | if(message) {
18 | await message.load();
19 | return true;
20 | }
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # See https://help.github.com/ignore-files/ for more about ignoring files.
2 |
3 | # compiled output
4 | /dist/
5 | /tmp/
6 |
7 | # dependencies
8 | /bower_components/
9 | /node_modules/
10 |
11 | # misc
12 | /.env*
13 | /.pnp*
14 | /.sass-cache
15 | /.eslintcache
16 | /connect.lock
17 | /coverage/
18 | /libpeerconnection.log
19 | /npm-debug.log*
20 | /testem.log
21 | /yarn-error.log
22 |
23 | # ember-try
24 | /.node_modules.ember-try/
25 | /bower.json.ember-try
26 | /npm-shrinkwrap.json.ember-try
27 | /package.json.ember-try
28 | /package-lock.json.ember-try
29 | /yarn.lock.ember-try
30 |
31 | .DS_Store
32 |
--------------------------------------------------------------------------------
/tests/dummy/app/instance-initializers/dummy.js:
--------------------------------------------------------------------------------
1 | import { initialize } from 'zuglet/initialize';
2 | import Store from '../store';
3 | import { registerDeprecationHandler } from '@ember/debug';
4 |
5 | export default {
6 | name: 'dummy:dev',
7 | initialize(app) {
8 | registerDeprecationHandler((message, options, next) => {
9 | if(options.id === 'manager-capabilities.modifiers-3-13') {
10 | return;
11 | }
12 | next(message, options, next);
13 | });
14 | initialize(app, {
15 | store: {
16 | identifier: 'store',
17 | factory: Store
18 | }
19 | });
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/addon/-private/factory/factory/-base.js:
--------------------------------------------------------------------------------
1 | import ZugletObject from '../../object';
2 |
3 | const factoryForPrefix = prefix => (_, key) => ({
4 | value(...args) {
5 | let { factory } = this;
6 | return factory[key].call(factory, prefix, ...args);
7 | }
8 | });
9 |
10 | export default prefix => {
11 |
12 | const factory = factoryForPrefix(prefix);
13 |
14 | return class Factory extends ZugletObject {
15 |
16 | @factory registerFactory
17 | @factory factoryFor
18 | @factory create
19 |
20 | constructor(owner, { factory }) {
21 | super(owner);
22 | this.factory = factory;
23 | }
24 |
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/blueprints/ember-cli-zuglet/files/__root__/instance-initializers/__name__-store.js:
--------------------------------------------------------------------------------
1 | import { initialize } from 'zuglet/initialize';
2 | import Store from '../store';
3 |
4 | export default {
5 | name: '<%= dasherizedPackageName %>:store',
6 | initialize(app) {
7 | initialize(app, {
8 | store: {
9 | identifier: 'store',
10 | factory: Store
11 | },
12 | // service: {
13 | // enabled: true,
14 | // name: 'store'
15 | // },
16 | // development: {
17 | // enabled: true,
18 | // logging: true,
19 | // export: 'store'
20 | // }
21 | });
22 | }
23 | };
24 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/query/array.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { root, activate } from 'zuglet/decorators';
3 | import { inject as service } from '@ember/service';
4 | import { setGlobal, toString } from 'zuglet/utils';
5 |
6 | @root()
7 | export default class RouteQueryArrayComponent extends Component {
8 |
9 | @service
10 | store
11 |
12 | @activate().content(({ store }) => store.collection('messages').query())
13 | query
14 |
15 | constructor() {
16 | super(...arguments);
17 | setGlobal({ component: this });
18 | }
19 |
20 | toString() {
21 | return toString(this);
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/firebase/standalone/lib/update-user-email.js:
--------------------------------------------------------------------------------
1 | let { withContext, argv, exit } = require('./setup');
2 |
3 | let { project, email, uid } = argv;
4 | if(!project) {
5 | exit('--project={{@message}}
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | {{this.model}}
2 | {{this.model.data.message}}
3 |
4 | {{!--
2 |
3 |
--------------------------------------------------------------------------------
/addon/-private/util/resolve.js:
--------------------------------------------------------------------------------
1 | import { isPromise } from './types';
2 |
3 | const promiseForType = (model, type) => {
4 | if(!model) {
5 | return;
6 | }
7 | let { promise } = model;
8 | if(!promise) {
9 | return;
10 | }
11 | if(type) {
12 | let nested = promise[type];
13 | if(nested) {
14 | return nested;
15 | }
16 | }
17 | return promise;
18 | }
19 |
20 | const toPromises = (args, type) => {
21 | let models = [];
22 |
23 | args.forEach(arg => {
24 | if(Array.isArray(arg)) {
25 | models.push(...arg);
26 | } else {
27 | models.push(arg);
28 | }
29 | });
30 |
31 | let promises = [];
32 |
33 | models.forEach(model => {
34 | if(!model) {
35 | return;
36 | }
37 | let promise = promiseForType(model, type);
38 | if(isPromise(promise)) {
39 | promises.push(promise);
40 | } else if(isPromise(model)) {
41 | promises.push(model);
42 | }
43 | });
44 |
45 | return promises;
46 | };
47 |
48 | const _resolve = type => (...args) => Promise.all(toPromises(args, type));
49 |
50 | const resolve = _resolve();
51 | resolve.cached = _resolve('cached');
52 | resolve.remote = _resolve('remote');
53 |
54 | export {
55 | resolve
56 | }
57 |
--------------------------------------------------------------------------------
/docs/api/firestore/reference/collection.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Collection
3 | pos: 3
4 | ---
5 |
6 | # Collection Reference `extends QueryableReference`
7 |
8 | See [Queryable Reference](api/firestore/reference/queryable) for query `load`, `query` and condition methods which are shared between `Collection`, `CollectionGroup` and `Condition` references.
9 |
10 | ``` javascript
11 | let ref = store.collection('messages');
12 | ```
13 |
14 | ## id `→ string`
15 |
16 | Document id
17 |
18 | ## path `→ string`
19 |
20 | Document path
21 |
22 | ## parent `→ DocumentReference`
23 |
24 | Creates a new [Document Reference](api/firestore/reference/document) which points to collections's parent
25 |
26 | ``` javascript
27 | let coll = store.doc('users/zeeba/messages');
28 | let ref = coll.parent;
29 | ref.path // → 'users/zeeba'
30 | ```
31 |
32 | ## doc(path)
33 |
34 | Creates a new [Document Reference](api/firestore/reference/document) which points to nested document.
35 |
36 | ``` javascript
37 | let coll = store.collection('users');
38 | let ref = coll.doc('zeeba');
39 | ref.path // → 'users/zeeba'
40 | ```
41 |
42 | ## dashboardURL `→ String`
43 |
44 | Firestore dashboard URL.
45 |
46 | ## openDashboard()
47 |
48 | `window.open` Firestore dashboard URL.
49 |
--------------------------------------------------------------------------------
/addon/-private/model/state/index.js:
--------------------------------------------------------------------------------
1 | import { getOwner } from '../../util/get-owner';
2 | import { assert } from '@ember/debug';
3 |
4 | const {
5 | assign
6 | } = Object;
7 |
8 | const marker = Symbol('ZUGLET');
9 |
10 | const createState = (owner, opts) => {
11 | let _owner = getOwner(owner, opts);
12 | if(!_owner) {
13 | return;
14 | }
15 | let factory;
16 | if(isRoot(owner)) {
17 | factory = _owner.factoryFor('zuglet:state/root');
18 | } else {
19 | factory = _owner.factoryFor('zuglet:state/model');
20 | }
21 |
22 | return new factory.class(_owner, { owner });
23 | }
24 |
25 | export const getState = (owner, opts) => {
26 | let { optional, create } = assign({ optional: false, create: true }, opts);
27 | assert(`owner is required`, !!owner);
28 |
29 | let state = owner[marker];
30 | if(!state && create) {
31 | state = createState(owner, { optional });
32 | if(state) {
33 | owner[marker] = state;
34 | state.didCreateState();
35 | }
36 | }
37 |
38 | return state;
39 | }
40 |
41 | const root = 'root';
42 |
43 | export const isRoot = instance => {
44 | return instance && instance.constructor[marker] === root;
45 | }
46 |
47 | export const setRoot = Class => {
48 | Class[marker] = root;
49 | }
50 |
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const MergeTrees = require('broccoli-merge-trees');
4 | const writeFile = require('broccoli-file-creator');
5 |
6 | const defaults = {
7 | proxyClassicSupport: false,
8 | stallThreshold: 5000,
9 | version: {
10 | zuglet: require('./package.json').version,
11 | firebase: require('firebase/package.json').version
12 | }
13 | };
14 |
15 | module.exports = {
16 | name: 'zuglet',
17 | isDevelopingAddon() {
18 | return true;
19 | },
20 | included(app, parentAddon) {
21 | this._super.included.apply(this, arguments);
22 | this.zuglet = Object.assign({}, defaults, (parentAddon || app).options['zuglet']);
23 | app.import('vendor/zuglet/fastboot.js');
24 | },
25 | treeForAddon() {
26 | let tree = this._super.treeForAddon.apply(this, arguments);
27 | return MergeTrees([
28 | tree,
29 | writeFile('-private/flags.js', `define('zuglet/-private/flags', [ 'exports' ], function(_exports) {
30 | "use strict";
31 |
32 | Object.defineProperty(_exports, "__esModule", {
33 | value: true
34 | });
35 |
36 | var _default = Object.freeze(${JSON.stringify(this.zuglet, null, 2)});
37 | _exports.default = _default;
38 | });`)
39 | ]);
40 | }
41 | };
42 |
--------------------------------------------------------------------------------
/addon/-private/store/firestore/references/collection.js:
--------------------------------------------------------------------------------
1 | import QueryableReference from './queryable';
2 | import { cached } from '../../../model/decorators/cached';
3 |
4 | export default class CollectionReference extends QueryableReference {
5 |
6 | get id() {
7 | return this._ref.id;
8 | }
9 |
10 | get path() {
11 | return this._ref.path;
12 | }
13 |
14 | @cached()
15 | get parent() {
16 | let ref = this._ref.parent;
17 | if(!ref) {
18 | return null;
19 | }
20 | return this.store.doc(ref);
21 | }
22 |
23 | //
24 |
25 | doc(path) {
26 | let _ref;
27 | if(path) {
28 | _ref = this._ref.doc(path);
29 | } else {
30 | _ref = this._ref.doc();
31 | }
32 | return this.store.doc(_ref);
33 | }
34 |
35 | //
36 |
37 | get dashboardURL() {
38 | let { store: { dashboardURL }, path } = this;
39 | return `${dashboardURL}/firestore/data/${path}`;
40 | }
41 |
42 | openDashboard() {
43 | window.open(this.dashboardURL, '_blank');
44 | }
45 |
46 | //
47 |
48 | get string() {
49 | return this.path;
50 | }
51 |
52 | get serialized() {
53 | let { id, path } = this;
54 | return { id, path };
55 | }
56 |
57 | toStringExtension() {
58 | return `${this.path}`;
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/docs/decorators/model.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: model
3 | pos: 4
4 | ---
5 |
6 | # @model
7 |
8 | Model decorator creates model instance with provided name and properties.
9 |
10 | ``` javascript
11 | import Component from '@glimmer/component';
12 | import { inject as service } from '@ember/service';
13 | import { root, model } from 'zuglet/decorators';
14 |
15 | @root()
16 | export default class NiceComponent extends Component {
17 |
18 | @service
19 | store
20 |
21 | @tracked
22 | type = 'message'
23 |
24 | @tracked
25 | id
26 |
27 | @model()
28 | .named(({ type }) => type)
29 | .mapping(({ store, id }) => ({ store, id }))
30 | .load(model => model.load()) // optional callback to load inner dependencies on 1st model activation
31 | model
32 |
33 | }
34 | ```
35 |
36 | ``` javascript
37 | // models/message.js
38 | import EmberObject from '@ember/object';
39 | export default class Message extends EmberObject {
40 |
41 | @tracked
42 | id
43 |
44 | @activate().content(({ store, id }) => store.doc(`messages/${id}`).existing())
45 | doc
46 |
47 | // optional. invoked if @model().mapping(fn) properties has changed
48 | // if not provided, model is recreated on mapping changes
49 | mappingDidChange({ id }) {
50 | this.id = id;
51 | }
52 |
53 | }
54 | ```
55 |
--------------------------------------------------------------------------------
/tests/dummy/config/environment.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const getConfig = require('../../../config');
4 |
5 | module.exports = function(environment) {
6 | let ENV = {
7 | modulePrefix: 'dummy',
8 | environment,
9 | rootURL: '/',
10 | locationType: 'history',
11 | EmberENV: {
12 | FEATURES: {
13 | },
14 | EXTEND_PROTOTYPES: {
15 | // Prevent Ember Data from overriding Date.parse.
16 | Date: false,
17 | },
18 | },
19 | APP: {
20 | },
21 | dummy: {
22 | firebase: getConfig('default').firebase,
23 | name: 'ember-cli-zuglet'
24 | },
25 | fastboot: {
26 | hostWhitelist: [ /^localhost:\d+$/ ]
27 | }
28 | };
29 |
30 | if(process.env.CI) {
31 | ENV.dummy.firebase = getConfig('travis').firebase;
32 | }
33 |
34 | console.log('Project:', ENV.dummy.firebase.projectId);
35 |
36 | if (environment === 'development') {
37 | //
38 | }
39 |
40 | if (environment === 'test') {
41 | ENV.locationType = 'none';
42 | ENV.APP.LOG_ACTIVE_GENERATION = false;
43 | ENV.APP.LOG_VIEW_LOOKUPS = false;
44 | ENV.APP.rootElement = '#ember-testing';
45 | ENV.APP.autoboot = false;
46 | }
47 |
48 | if (environment === 'production') {
49 | //
50 | }
51 |
52 | return ENV;
53 | };
54 |
--------------------------------------------------------------------------------
/blueprints/ember-cli-zuglet/files/__root__/store.js:
--------------------------------------------------------------------------------
1 | import Store from 'zuglet/store';
2 |
3 | const options = {
4 | firebase: {
5 | apiKey: '',
6 | authDomain: '',
7 | databaseURL: '',
8 | projectId: '',
9 | storageBucket: '',
10 | messagingSenderId: ''
11 | },
12 | firestore: {
13 | persistenceEnabled: true,
14 | // experimentalAutoDetectLongPolling: true,
15 | // experimentalForceLongPolling: true
16 | },
17 | auth: {
18 | user: 'user'
19 | },
20 | // functions: {
21 | // region: null
22 | // },
23 | // emulators: {
24 | // host: 'localhost',
25 | // auth: 9099,
26 | // firestore: 8080,
27 | // storage: 9199,
28 | // functions: 5001
29 | // }
30 | };
31 |
32 | if(!options.firebase.projectId) {
33 | // eslint-disable-next-line no-console
34 | console.log([
35 | '',
36 | '🔥',
37 | '',
38 | 'No Firebase config provided.',
39 | 'Get your Firebase project configuration from https://console.firebase.google.com/',
40 | 'and paste it in the `app/store.js`',
41 | '',
42 | ''
43 | ].join('\n'));
44 |
45 | throw new Error('No firebase config provided in app/store.js');
46 | }
47 |
48 | export default class <%= classifiedPackageName %>Store extends Store {
49 |
50 | options = options
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/addon/-private/util/types.js:
--------------------------------------------------------------------------------
1 | import firebase from "firebase/compat/app";
2 | import { isArray } from '@ember/array';
3 |
4 | export {
5 | isArray
6 | }
7 |
8 | let _serverTimestamp;
9 | export const isServerTimestamp = arg => {
10 | if(!_serverTimestamp) {
11 | _serverTimestamp = firebase.firestore.FieldValue.serverTimestamp();
12 | }
13 | return !!arg && typeof arg === 'object' && _serverTimestamp.isEqual(arg);
14 | };
15 |
16 | export const isTimestamp = arg => arg instanceof firebase.firestore.Timestamp;
17 | export const isDocumentReference = arg => arg instanceof firebase.firestore.DocumentReference;
18 | export const isCollectionReference = arg => arg instanceof firebase.firestore.CollectionReference;
19 | export const isGeoPoint = arg => arg instanceof firebase.firestore.GeoPoint;
20 | export const isFirestoreBlob = arg => arg instanceof firebase.firestore.Blob;
21 |
22 | export const isFunction = arg => typeof arg === 'function';
23 |
24 | const hasFileList = () => ('FileList' in window);
25 | const hasFile = () => ('File' in window);
26 |
27 | export const isDate = arg => arg instanceof Date;
28 | export const isFileList = arg => hasFileList() && arg instanceof FileList;
29 | export const isFile = arg => hasFile() && arg instanceof File;
30 | export const isPromise = arg => arg && isFunction(arg.then);
31 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/hljs/tomorrow.scss:
--------------------------------------------------------------------------------
1 | /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
2 |
3 | /* Tomorrow Comment */
4 | .hljs-comment,
5 | .hljs-quote {
6 | color: #8e908c;
7 | }
8 |
9 | /* Tomorrow Red */
10 | .hljs-variable,
11 | .hljs-template-variable,
12 | .hljs-tag,
13 | .hljs-name,
14 | .hljs-selector-id,
15 | .hljs-selector-class,
16 | .hljs-regexp,
17 | .hljs-deletion {
18 | color: #c82829;
19 | }
20 |
21 | /* Tomorrow Orange */
22 | .hljs-number,
23 | .hljs-built_in,
24 | .hljs-builtin-name,
25 | .hljs-literal,
26 | .hljs-type,
27 | .hljs-params,
28 | .hljs-meta,
29 | .hljs-link {
30 | color: #f5871f;
31 | }
32 |
33 | /* Tomorrow Yellow */
34 | .hljs-attribute {
35 | color: #eab700;
36 | }
37 |
38 | /* Tomorrow Green */
39 | .hljs-string,
40 | .hljs-symbol,
41 | .hljs-bullet,
42 | .hljs-addition {
43 | color: #f5871f;
44 | }
45 |
46 | /* Tomorrow Blue */
47 | .hljs-title,
48 | .hljs-section {
49 | color: #4271ae;
50 | }
51 |
52 | /* Tomorrow Purple */
53 | .hljs-keyword,
54 | .hljs-selector-tag {
55 | color: #718c00;
56 | }
57 |
58 | .hljs {
59 | display: block;
60 | overflow-x: auto;
61 | background: white;
62 | color: #4d4d4c;
63 | padding: 0.5em;
64 | }
65 |
66 | .hljs-emphasis {
67 | font-style: italic;
68 | }
69 |
70 | .hljs-strong {
71 | font-weight: bold;
72 | }
--------------------------------------------------------------------------------
/docs/decorators/activate.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: activate
3 | pos: 3
4 | ---
5 |
6 | # @activate
7 |
8 | Activate decorator activates and deactivates property value based on parent's state.
9 |
10 | ## @activate().content(fn)
11 |
12 | ``` javascript
13 | // models/message.js
14 | import EmberObject from '@ember/object';
15 | import { inject as service } from '@ember/service';
16 | import { activate } from 'zuglet/decorators';
17 |
18 | export default class Message extends EmberObject {
19 |
20 | @service
21 | store
22 |
23 | @tracked
24 | id
25 |
26 | @activate().content(({ store, id }) => store.doc(`messages/${id}`).existing())
27 | doc
28 |
29 | }
30 | ```
31 |
32 | ## @activate()
33 |
34 | If you don't provide `content()`, `@activate` acts as a writable property which activates set value
35 |
36 | ``` javascript
37 | // models/message.js
38 | import EmberObject from '@ember/object';
39 | import { inject as service } from '@ember/service';
40 | import { activate } from 'zuglet/decorators';
41 |
42 | export default class Message extends EmberObject {
43 |
44 | @service
45 | store
46 |
47 | @activate()
48 | doc
49 |
50 | update(id) {
51 | // previous doc value is deactivated
52 | // new doc value is activated
53 | this.doc = this.store.doc(`messages/${id}`).existing();
54 | }
55 |
56 | }
57 | ```
58 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/messages.js:
--------------------------------------------------------------------------------
1 | import ZugletObject from 'zuglet/object';
2 | import { inject as service } from '@ember/service';
3 | import { objectToJSON, toJSON, load } from 'zuglet/utils';
4 | import { activate, models } from 'zuglet/decorators';
5 |
6 | export default class Messages extends ZugletObject {
7 |
8 | @service store;
9 |
10 | get coll() {
11 | return this.store.collection('messages');
12 | }
13 |
14 | @activate()
15 | .content(({ coll }) => coll.query())
16 | query;
17 |
18 | @models()
19 | .source(({ query }) => query.content)
20 | .named(doc => {
21 | if(doc.data.name ==='first') {
22 | return 'fancy-message';
23 | }
24 | return 'message';
25 | })
26 | .mapping(doc => ({ doc }))
27 | models;
28 |
29 | async load() {
30 | await load.cached(this.query);
31 | }
32 |
33 | async add(name) {
34 | let doc = this.store.collection('messages').doc().new({ name });
35 | await doc.save();
36 | return doc;
37 | }
38 |
39 | byId(id) {
40 | return this.models.find(model => model.id === id);
41 | }
42 |
43 | get serialized() {
44 | let { models } = this;
45 | return {
46 | models: objectToJSON(models)
47 | };
48 | }
49 |
50 | toJSON() {
51 | let { serialized } = this;
52 | return toJSON(this, { serialized });
53 | }
54 |
55 | }
56 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/remark.scss:
--------------------------------------------------------------------------------
1 | .remark {
2 | > .root {
3 | @import "hljs/index";
4 | @mixin header-code() {
5 | > code {
6 | font-family: $font-code;
7 | display: inline-block;
8 | font-size: 14px;
9 | }
10 | }
11 | h1 {
12 | font-weight: 400;
13 | font-size: 21px;
14 | margin: 40px 0 0 0;
15 | @include header-code();
16 | }
17 | h2 {
18 | font-weight: 400;
19 | font-size: 18px;
20 | margin: 50px 0 0 0;
21 | @include header-code();
22 | }
23 | h1 + h2 {
24 | margin-top: 40px;
25 | }
26 | h3 {
27 | font-weight: 400;
28 | font-size: 17px;
29 | margin: 48px 0 0 0;
30 | @include header-code();
31 | }
32 | h2 + h3 {
33 | margin-top: 48px;
34 | }
35 | blockquote {
36 | margin: 0;
37 | border-left: 2px solid #ddd;
38 | padding: 0 0 0 10px;
39 | }
40 | li {
41 | padding: 0 0 5px 0;
42 | > p {
43 | margin: 0;
44 | }
45 | &:last-child {
46 | padding: 0;
47 | }
48 | }
49 | > *:first-child {
50 | margin-top: 15px;
51 | }
52 | code {
53 | font-family: $font-code;
54 | display: inline-block;
55 | font-weight: 600;
56 | }
57 | pre code {
58 | font-weight: 400;
59 | }
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/firebase/standalone/lib/setup.js:
--------------------------------------------------------------------------------
1 | const admin = require('firebase-admin');
2 | const getConfig = require('../../../config');
3 |
4 | const initializeAdmin = (config, name) => {
5 | let { firebase, serviceAccountKey } = config;
6 | let credential = admin.credential.cert(require(serviceAccountKey));
7 | return admin.initializeApp(Object.assign({}, firebase, { credential }), name);
8 | };
9 |
10 | class Context {
11 |
12 | constructor(fullName) {
13 | this.fullName = fullName;
14 | this.config = getConfig(fullName);
15 | this.admin = initializeAdmin(this.config, fullName);
16 | this.firestore = this.admin.firestore();
17 | this.auth = this.admin.auth();
18 | this.storage = this.admin.storage();
19 | this.bucket = this.storage.bucket();
20 | }
21 |
22 | }
23 |
24 | const argv = require('minimist')(process.argv.slice(2));
25 |
26 | const run = fn => Promise.resolve(fn()).then(arg => arg, err => {
27 | console.error(err.stack);
28 | process.exit(-1);
29 | });
30 |
31 | const withContext = (fullName, fn) => run(async () => {
32 | let context = new Context(fullName);
33 | let result = await fn(context);
34 | context.admin.delete();
35 | return result;
36 | });
37 |
38 | const exit = message => {
39 | console.error(message);
40 | process.exit(-1);
41 | }
42 |
43 | module.exports = {
44 | Context,
45 | run,
46 | withContext,
47 | argv,
48 | exit
49 | };
50 |
--------------------------------------------------------------------------------
/tests/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 | {{#let this.first as |model|}}
15 | #{{model.position}}: {{model.title}}
16 | {{/let}}
17 |
18 |
19 |
20 | {{#each this.query.content as |doc|}}
21 |
29 |
30 |
22 | #{{doc.data.position}}: {{doc.data.title}}
23 | [Up]
24 | [Down]
25 | [Delete]
26 |
27 | {{/each}}
28 |
31 | {{#each this.models as |model|}}
32 |
37 |
38 |
33 | #{{model.position}}: {{model.title}}
34 |
35 | {{/each}}
36 |
26 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 | {{content-for "body-footer"}}
38 | {{content-for "test-body-footer"}}
39 |
40 |
41 |
--------------------------------------------------------------------------------
/docs/api/stores/stats.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Stats
3 | pos: 0
4 | ---
5 |
6 | # Stats
7 |
8 | List of currently:
9 |
10 | * activated models, documents, queries, …
11 | * observed documents, queries, auth, tasks
12 | * pending promises
13 |
14 | ``` javascript
15 | import { getStores } from 'zuglet/utils';
16 |
17 | let stats = getStores(this).stats;
18 | ```
19 |
20 | ``` javascript
21 | let stats = store.stores.stats;
22 | ```
23 |
24 | ## activated
25 |
26 | List of activated models, documents, queries, …
27 |
28 | Useful for debugging.
29 |
30 | ## observers
31 |
32 | List of documents, queries, auth state change and storage tasks being observed.
33 |
34 | Useful for debugging.
35 |
36 | ## promises
37 |
38 | List of currently running promises which are not yet settled. Each promise has `stats` property with `{ model, label }` for debugging.
39 |
40 | ``` javascript
41 | let promise = stats.promises[0];
42 | promise.stats.model // →
27 |
28 |
29 |
2 |
3 |
--------------------------------------------------------------------------------
/docs/api/auth/user.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: User
3 | pos: 0
4 | ---
5 |
6 | # User
7 |
8 | Currently signed in user.
9 |
10 | See [Store](api/store) `options.auth.user` on how to provide custom `User` implementation
11 |
12 | ## user
13 |
14 | Firebase Auth User instance
15 |
16 | ## props
17 |
18 | aliases of `this.user[key]`
19 |
20 | * uid
21 | * email
22 | * emailVerified
23 | * photoURL
24 | * displayName
25 | * isAnonymous
26 |
27 | ## restore(user)
28 |
29 | Override to load additional data on user sign-up/sign-in.
30 |
31 | ``` javascript
32 | import User from 'zuglet/user';
33 | import { load } from 'zuglet/util';
34 |
35 | export default class User extends BaseUser {
36 |
37 | @activate().content(({ store, uid }) => store.doc(`users/${uid}`).existing())
38 | doc
39 |
40 | async restore(user) {
41 | super.restore(user);
42 | await load(this.doc);
43 | }
44 |
45 | }
46 | ```
47 |
48 | ## signOut()
49 |
50 | Alias of `store.auth.signOut()`
51 |
52 | ## token({ type, refresh })
53 |
54 | Fetch user's token.
55 |
56 | * `type` → defaults to `string`. `string` or `json`
57 | * `refresh` → defaults to `false`
58 |
59 | ``` javascript
60 | let token = store.auth.user.token({ type: 'json' });
61 | ```
62 |
63 | ## link(method, ...args)
64 |
65 | Link user accounts.
66 |
67 | * `method` → string
68 | * `...args` → arguments forwarded to method's credentials
69 |
70 | ``` javascript
71 | await store.auth.user.link('email', 'email@address.com', 'heythere')
72 | ```
73 |
74 | ## async updatePassword(newPassword) `→ undefined`
75 |
76 | ``` javascript
77 | await store.auth.user.updatePassword(newPassword);
78 | ```
79 |
--------------------------------------------------------------------------------
/tests/dummy/app/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
17 |
18 | {{content-for "head"}}
19 |
20 |
21 |
22 |
23 | {{content-for "head-footer"}}
24 |
25 |
26 | {{content-for "body"}}
27 |
28 |
29 |
30 |
31 | {{content-for "body-footer"}}
32 |
33 |
34 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/index.hbs:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 |
8 |
9 |
16 |
17 |
10 | {{if this.url this.url 'No url'}}
11 |
12 |
13 |
14 |
15 |
18 |
29 |
30 |
19 | {{#if this.metadata}}
20 |
21 | {{else}}
22 | No metadata
23 | {{/if}}
24 |
25 |
26 |
27 |
28 |
31 |
32 |
33 |
34 | {{#if this.file}}
35 |
36 |
37 |
38 |
39 |
40 |
41 | {{/if}}
42 |
43 | {{#if this.task}}
44 | {{#if this.task.isCompleted}}
45 |
46 | Uploaded successfully
47 |
48 | {{else if this.task.isRunning}}
49 |
50 | Uploading {{this.task.progress}}%…
51 |
52 | {{/if}}
53 |
54 |
55 |
56 | {{/if}}
57 |
58 |
2 |
3 |
4 |
5 |
8 |
9 |
10 | Documentation
11 | Experiments
12 | GitHub
13 |
14 |
15 |
16 |
17 |
18 |
19 | {{!--
20 |
21 | --}}
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
37 |
38 |
--------------------------------------------------------------------------------
/addon/-private/model/properties/activate/activate.js:
--------------------------------------------------------------------------------
1 | import Property from '../property';
2 | import { assert } from '@ember/debug';
3 | import { isArray } from '@ember/array';
4 | import ObjectActivator from './activators/object';
5 | import ArrayActivator from './activators/array';
6 |
7 | export default class BaseActivateProperty extends Property {
8 |
9 | _activatorTypeForValue(value) {
10 | if(isArray(value)) {
11 | return 'array';
12 | } else {
13 | return 'object';
14 | }
15 | }
16 |
17 | activatorTypeForValue(value) {
18 | let type = this._activatorTypeForValue(value);
19 | let { activator } = this;
20 | if(activator && value === null || value === undefined) {
21 | return activator.type;
22 | }
23 | return type;
24 | }
25 |
26 | createActivator(value) {
27 | if(isArray(value)) {
28 | return new ArrayActivator(this, value);
29 | }
30 | return new ObjectActivator(this, value);
31 | }
32 |
33 | assertActivatorType(activator, value) {
34 | assert([
35 | `Changing activator type is not supported.`,
36 | `Now property '${this.key}' for ${this.owner} is of type ${activator.type}`,
37 | `but value '${value}' asks for activator of type ${this.activatorTypeForValue(value)}`
38 | ].join(' '), activator.type === this.activatorTypeForValue(value));
39 | }
40 |
41 | //
42 |
43 | onActivated() {
44 | let { activator } = this;
45 | if(activator) {
46 | activator.activate();
47 | }
48 | }
49 |
50 | onDeactivated() {
51 | let { activator } = this;
52 | if(activator) {
53 | activator.deactivate();
54 | }
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/addon/-private/util/error.js:
--------------------------------------------------------------------------------
1 | import { isFunction } from './types';
2 |
3 | const {
4 | assign
5 | } = Object;
6 |
7 | export class ZugletError extends Error {
8 |
9 | get serialized() {
10 | return Object.getOwnPropertyNames(this).reduce((hash, key) => {
11 | hash[key] = this[key];
12 | return hash;
13 | }, {});
14 | }
15 |
16 | toJSON() {
17 | let { serialized } = this;
18 | return { type: 'zuglet-error', serialized };
19 | }
20 |
21 | }
22 |
23 | export const error = opts => {
24 | let { message, code } = opts;
25 | delete opts.message;
26 | delete opts.code;
27 |
28 | let err = new ZugletError(message);
29 | err.code = `zuglet/${code}`;
30 | assign(err, opts);
31 |
32 | return err;
33 | }
34 |
35 | export const documentForRefNotFoundError = ref => error({
36 | message: `Document '${ref.path}' missing`,
37 | code: 'document/missing',
38 | path: ref.path
39 | });
40 |
41 | export const documentNotFoundError = () => error({
42 | message: `Document missing`,
43 | code: 'document/missing'
44 | });
45 |
46 | export const cancelledError = () => error({
47 | message: 'Snapshot cancelled',
48 | code: 'snapshot/cancelled'
49 | });
50 |
51 | export const timeoutError = () => error({
52 | message: 'Snapshot timeout',
53 | code: 'snapshot/timeout'
54 | });
55 |
56 | export const assert = (message, condition) => {
57 | if(!condition) {
58 | if(isFunction(message)) {
59 | message = message();
60 | }
61 | throw error({
62 | message,
63 | code: 'assert'
64 | });
65 | }
66 | };
67 |
68 | export const isZugletError = err => {
69 | return err instanceof ZugletError;
70 | };
71 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/route/index.scss:
--------------------------------------------------------------------------------
1 | .route-index {
2 | margin: 80px 50px 33px 50px;
3 | max-width: 800px;
4 | @include breakpoint(tablet) {
5 | margin: 50px 40px;
6 | }
7 | @include breakpoint(mobile) {
8 | margin: 25px 20px;
9 | }
10 | }
11 |
12 | .block-index-section {
13 | margin-bottom: 33px;
14 |
15 | display: flex;
16 | flex-direction: row;
17 | align-items: baseline;
18 |
19 | > .aside {
20 | font-size: $font-size-smaller;
21 | text-transform: uppercase;
22 | width: 70px;
23 | opacity: 0.3;
24 | }
25 |
26 | > .content {
27 | flex: 1;
28 | overflow-x: hidden;
29 | }
30 |
31 | @include breakpoint(mobile) {
32 | > .aside {
33 | display: none;
34 | }
35 | }
36 |
37 | &.header {
38 | > .content {
39 | > .fire {
40 | font-size: 32px;
41 | line-height: 1;
42 | &:after {
43 | content: '🔥';
44 | }
45 | @include breakpoint(non-desktop) {
46 | margin-bottom: 10px;
47 | }
48 | }
49 | > .header {
50 | font-size: $font-size * 2;
51 | > .value {
52 | font-weight: 600;
53 | }
54 | @include breakpoint(mobile) {
55 | > .prefix {
56 | display: none;
57 | }
58 | }
59 | }
60 | }
61 | }
62 |
63 | &.links {
64 | > .content {
65 | display: flex;
66 | flex-direction: row;
67 | font-weight: 600;
68 | > a {
69 | margin-right: 10px;
70 | }
71 | }
72 | }
73 |
74 | &.author {
75 | > .content {
76 | > p {
77 | margin-bottom: 0;
78 | }
79 | }
80 | }
81 | }
82 |
--------------------------------------------------------------------------------
/addon/-private/store/storage/storage.js:
--------------------------------------------------------------------------------
1 | import 'firebase/compat/storage';
2 | import ZugletObject from '../../../object';
3 | import { toJSON } from '../../util/to-json';
4 | import { getFactory } from '../../factory/get-factory';
5 |
6 | export default class Storage extends ZugletObject {
7 |
8 | constructor(owner, { store }) {
9 | super(owner);
10 | this.store = store;
11 | this._maybeSetupEmulator();
12 | }
13 |
14 | _maybeSetupEmulator() {
15 | let emulators = this.store.normalizedOptions.emulators;
16 | if(emulators.storage) {
17 | this._storage.useEmulator(emulators.storage.host, emulators.storage.port);
18 | }
19 | }
20 |
21 | get _storage() {
22 | return this.store.firebase.storage();
23 | }
24 |
25 | get bucket() {
26 | return this._storage.app.options.storageBucket;
27 | }
28 |
29 | _createReference(_ref) {
30 | let storage = this;
31 | return getFactory(this).zuglet.create('store/storage/reference', { storage, _ref });
32 | }
33 |
34 | ref(arg) {
35 | if(typeof arg === 'string') {
36 | arg = { path: arg };
37 | }
38 |
39 | let { path, url } = arg;
40 | let _ref;
41 | if(path) {
42 | _ref = this._storage.ref(path);
43 | } else {
44 | _ref = this._storage.refFromURL(url);
45 | }
46 |
47 | return this._createReference(_ref);
48 | }
49 |
50 | get serialized() {
51 | let { bucket } = this;
52 | return {
53 | bucket
54 | };
55 | }
56 |
57 | toJSON() {
58 | let { serialized } = this;
59 | return toJSON(this, { serialized });
60 | }
61 |
62 | toStringExtension() {
63 | return `${this.bucket}`;
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | ---
2 | language: node_js
3 | node_js:
4 | # we recommend testing addons with the same minimum supported node version as Ember CLI
5 | # so that your addon works for all apps
6 | - "12"
7 |
8 | dist: xenial
9 |
10 | addons:
11 | chrome: stable
12 |
13 | cache:
14 | directories:
15 | - $HOME/.npm
16 |
17 | env:
18 | global:
19 | # See https://git.io/vdao3 for details.
20 | - JOBS=1
21 |
22 | branches:
23 | only:
24 | - master
25 | # npm version tags
26 | - /^v\d+\.\d+\.\d+/
27 |
28 | jobs:
29 | fast_finish: true
30 | allow_failures:
31 | - env: EMBER_TRY_SCENARIO=ember-canary
32 |
33 | include:
34 | # runs linting and tests with current locked deps
35 | - stage: "Tests"
36 | name: "Tests"
37 | script:
38 | - npm run lint
39 | - npm run test:ember
40 |
41 | - stage: "Additional Tests"
42 | name: "Floating Dependencies"
43 | install:
44 | - npm install --no-package-lock
45 | script:
46 | - npm run test:ember
47 |
48 | # we recommend new addons test the current and previous LTS
49 | # as well as latest stable release (bonus points to beta/canary)
50 | - env: EMBER_TRY_SCENARIO=ember-lts-3.20
51 | - env: EMBER_TRY_SCENARIO=ember-lts-3.24
52 | - env: EMBER_TRY_SCENARIO=ember-release
53 | - env: EMBER_TRY_SCENARIO=ember-beta
54 | - env: EMBER_TRY_SCENARIO=ember-canary
55 | - env: EMBER_TRY_SCENARIO=ember-default-with-jquery
56 | - env: EMBER_TRY_SCENARIO=ember-classic
57 | - env: EMBER_TRY_SCENARIO=embroider-safe
58 | - env: EMBER_TRY_SCENARIO=embroider-optimized
59 |
60 | script:
61 | - node_modules/.bin/ember try:one $EMBER_TRY_SCENARIO
62 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/storage.js:
--------------------------------------------------------------------------------
1 | import Component from '@glimmer/component';
2 | import { inject as service } from '@ember/service';
3 | import { setGlobal, toString } from 'zuglet/utils';
4 | import { root, activate } from 'zuglet/decorators';
5 | import { action } from '@ember/object';
6 | import { tracked } from '@glimmer/tracking';
7 |
8 | @root()
9 | export default class RouteStorageComponent extends Component {
10 |
11 | @service
12 | store
13 |
14 | @tracked
15 | file
16 |
17 | @tracked
18 | url
19 |
20 | @tracked
21 | metadata
22 |
23 | @activate()
24 | task
25 |
26 | constructor() {
27 | super(...arguments);
28 | setGlobal({ component: this });
29 | }
30 |
31 | @action
32 | onFile(file) {
33 | this.file = file;
34 | }
35 |
36 | @action
37 | upload() {
38 | let { file } = this;
39 | this.file = null;
40 | let task = this.store.storage.ref('hello').put({
41 | type: 'data',
42 | data: file,
43 | metadata: {
44 | contentType: file.type,
45 | contentDisposition: `filename="${file.name}"`
46 | }
47 | });
48 | this.task = task;
49 | }
50 |
51 | @action
52 | async getUrl() {
53 | try {
54 | let url = await this.store.storage.ref('hello').url();
55 | this.url = url;
56 | } catch(err) {
57 | this.url = err;
58 | }
59 | }
60 |
61 | @action
62 | async getMetadata() {
63 | try {
64 | let metadata = await this.store.storage.ref('hello').metadata();
65 | this.metadata = metadata;
66 | } catch(err) {
67 | this.metadata = err;
68 | }
69 | }
70 |
71 | toString() {
72 | return toString(this);
73 | }
74 |
75 | }
76 |
--------------------------------------------------------------------------------
/addon/-private/store/auth/methods/email.js:
--------------------------------------------------------------------------------
1 | import AuthMethod from './method';
2 | import firebase from 'firebase/compat/app';
3 | import { registerPromise } from '../../../stores/stats';
4 |
5 | const {
6 | assign
7 | } = Object;
8 |
9 | export default class EmailAuthMethod extends AuthMethod {
10 |
11 | signIn(email, password) {
12 | return this.auth._withAuthReturningUser(async auth => {
13 | let { user } = await registerPromise(this, 'sign-in', true, auth.signInWithEmailAndPassword(email, password));
14 | return { user };
15 | });
16 | }
17 |
18 | signUp(email, password) {
19 | return this.auth._withAuthReturningUser(async auth => {
20 | let { user } = await registerPromise(this, 'sign-up', true, auth.createUserWithEmailAndPassword(email, password));
21 | return { user };
22 | });
23 | }
24 |
25 | sendSignInLink(email, opts) {
26 | opts = assign({ handleCodeInApp: true }, opts);
27 | return this.auth._withAuth(async auth => {
28 | await registerPromise(this, 'send-link', true, auth.sendSignInLinkToEmail(email, opts));
29 | });
30 | }
31 |
32 | signInWithLink(email, link) {
33 | return this.auth._withAuthReturningUser(async auth => {
34 | let { user } = await registerPromise(this, 'sign-in-with-link', true, auth.signInWithEmailLink(email, link));
35 | return { user };
36 | });
37 | }
38 |
39 | credential(email, password) {
40 | return firebase.auth.EmailAuthProvider.credential(email, password);
41 | }
42 |
43 | sendPasswordReset(email, opts) {
44 | return this.auth._withAuth(auth => {
45 | return registerPromise(this, 'send-password-reset', true, auth.sendPasswordResetEmail(email, opts));
46 | });
47 | }
48 |
49 | }
50 |
--------------------------------------------------------------------------------
/addon/-private/util/object-to-json.js:
--------------------------------------------------------------------------------
1 | import {
2 | isTimestamp,
3 | isServerTimestamp,
4 | isGeoPoint,
5 | isFunction,
6 | isArray,
7 | isDate,
8 | isFile,
9 | isFileList,
10 | isFirestoreBlob
11 | } from './types';
12 |
13 | import {
14 | formatDate
15 | } from './date';
16 |
17 | export const objectToJSON = value => {
18 | if(typeof value === 'object') {
19 | if(value === null) {
20 | return value;
21 | } else if(isTimestamp(value)) {
22 | return {
23 | type: 'timestamp',
24 | value: formatDate(value.toDate())
25 | };
26 | } else if(isGeoPoint(value)) {
27 | let json = value.toJSON();
28 | return {
29 | type: 'geopoint',
30 | ...json
31 | };
32 | } else if(isFunction(value.toJSON)) {
33 | return value.toJSON();
34 | } else if(isArray(value)) {
35 | return value.map(item => objectToJSON(item));
36 | } else if(isDate(value)) {
37 | return {
38 | type: 'date',
39 | value: formatDate(value)
40 | };
41 | } else if(isFile(value)) {
42 | let { name, type: contentType, size } = value;
43 | return {
44 | type: 'file',
45 | name,
46 | contentType,
47 | size
48 | };
49 | } else if(isFileList(value)) {
50 | let files = [ ...value ];
51 | return files.map(file => objectToJSON(file));
52 | } else if(isServerTimestamp(value)) {
53 | return {
54 | type: 'server-timestamp',
55 | };
56 | } else if(isFirestoreBlob(value)) {
57 | return {
58 | type: 'firestore-blob',
59 | };
60 | } else {
61 | let hash = {};
62 | Object.getOwnPropertyNames(value).forEach(key => {
63 | hash[key] = objectToJSON(value[key]);
64 | });
65 | return hash;
66 | }
67 | }
68 | return value;
69 | };
70 |
--------------------------------------------------------------------------------
/tests/dummy/app/router.js:
--------------------------------------------------------------------------------
1 | import EmberRouter from '@ember/routing/router';
2 | import config from 'dummy/config/environment';
3 | import { isFastBoot } from 'zuglet/-private/util/fastboot';
4 |
5 | let {
6 | environment
7 | } = config;
8 |
9 | let isGoogleAnalyticsEnabled = environment === 'production';
10 |
11 | export default class Router extends EmberRouter {
12 | location = config.locationType;
13 | rootURL = config.rootURL;
14 |
15 | constructor() {
16 | super(...arguments);
17 | this.on('routeDidChange', () => this.routeDidChange());
18 | }
19 |
20 | sendPageview() {
21 | if(!isGoogleAnalyticsEnabled) {
22 | return;
23 | }
24 | if(typeof gtag_pageview !== 'undefined') {
25 | let url = this.currentURL;
26 | gtag_pageview(url); /* eslint-disable-line no-undef */
27 | }
28 | }
29 |
30 | routeDidChange() {
31 | if(!isFastBoot(this)) {
32 | this.sendPageview();
33 | }
34 | }
35 |
36 | }
37 |
38 | Router.map(function() {
39 |
40 | this.route('docs', function() {
41 | this.route('page', { path: '/*page_id' }, function() {
42 | });
43 | });
44 |
45 | this.route('playground', function() {
46 | this.route('document');
47 | this.route('query', function() {
48 | this.route('array');
49 | this.route('single');
50 | });
51 | this.route('models');
52 | this.route('content');
53 | this.route('route');
54 | this.route('auth', function() {
55 | this.route('email', { path: 'email/:email' });
56 | });
57 | this.route('storage');
58 | this.route('functions');
59 | this.route('dev');
60 | this.route('reordering');
61 | this.route('messages', function() {
62 | this.route('message', { path: ':message_id' }, function() {
63 | });
64 | });
65 | });
66 |
67 | this.route('missing', { path: '/*path' });
68 |
69 | });
70 |
--------------------------------------------------------------------------------
/tests/dummy/app/styles/body.scss:
--------------------------------------------------------------------------------
1 | html {
2 | padding: 0;
3 | margin: 0;
4 | height: 100%;
5 | }
6 |
7 | body {
8 | padding: 0;
9 | margin: 0;
10 | font-family: $font-text;
11 | font-size: $font-size;
12 | line-height: 1.3;
13 | cursor: default;
14 | height: 100%;
15 | min-height: 100%;
16 | display: flex;
17 | flex-direction: column;
18 | }
19 |
20 | * {
21 | box-sizing: border-box;
22 | }
23 |
24 | #qunit {
25 | button {
26 | color: #000;
27 | background: #fff !important;
28 | border: 1px solid fade-out(#000, 0.75) !important;
29 | }
30 | }
31 |
32 | @mixin button() {
33 | font-family: $font-code;
34 | font-size: $font-size;
35 | background: fade-out(#000, 0.2);
36 | border-radius: 3px;
37 | border: none;
38 | color: #fff;
39 | padding: 5px 9px 5px 9px;
40 | outline: none;
41 | font-size: 14px;
42 | margin: 0;
43 | }
44 |
45 | a,
46 | a:visited,
47 | a:active {
48 | color: #000;
49 | text-decoration: underline;
50 | text-decoration-color: fade-out(#000, 0.8);
51 | transition: text-decoration-color 0.2s ease-in-out;
52 | &:hover {
53 | text-decoration-color: fade-out(#000, 0.1);
54 | }
55 | }
56 |
57 | button,
58 | input[type="button"] {
59 | @include button();
60 | }
61 |
62 | button:disabled,
63 | input[type="button"]:disabled {
64 | color: #999;
65 | }
66 |
67 | input:not([type]),
68 | input[type="text"],
69 | input[type="number"],
70 | input[type="password"] {
71 | font-family: $font-code;
72 | font-size: $font-size;
73 | border-radius: 3px;
74 | border: 1px solid #999;
75 | padding: 4px 9px 4px 9px;
76 | margin: 0;
77 | line-height: 1;
78 | outline: none;
79 | }
80 |
81 | textarea {
82 | font-family: $font-code;
83 | font-size: $font-size;
84 | border-radius: 3px;
85 | border: 1px solid #999;
86 | padding: 5px;
87 | margin: 0;
88 | line-height: 1;
89 | outline: none;
90 | }
91 |
--------------------------------------------------------------------------------
/tests/unit/auth-test.js:
--------------------------------------------------------------------------------
1 | import { module, test, setupStoreTest, credentials } from '../helpers/setup';
2 |
3 | module('auth', function(hooks) {
4 | setupStoreTest(hooks);
5 |
6 | hooks.beforeEach(async function() {
7 | this.auth = this.store.auth;
8 | await this.auth.signOut();
9 | });
10 |
11 | hooks.afterEach(async function() {
12 | await this.auth.signOut();
13 | });
14 |
15 | test('user delete', async function(assert) {
16 | let user = await this.auth.methods.anonymous.signIn();
17 | await user.delete();
18 | assert.strictEqual(this.auth.user, null);
19 | });
20 |
21 | test('serialized', async function(assert) {
22 | assert.deepEqual(this.auth.serialized, {
23 | user: null
24 | });
25 | });
26 |
27 | test('serialized with signed in user', async function(assert) {
28 | await this.auth.methods.email.signIn(credentials.ampatspell.email, credentials.ampatspell.password);
29 | let { serialized } = this.auth;
30 | assert.deepEqual(serialized, {
31 | user: {
32 | instance: serialized.user.instance,
33 | serialized: {
34 | email: credentials.ampatspell.email,
35 | emailVerified: serialized.user.serialized.emailVerified,
36 | isAnonymous: false,
37 | uid: serialized.user.serialized.uid
38 | }
39 | }
40 | });
41 | assert.ok(serialized.user.instance.startsWith('dummy@model:test-user::ember'));
42 | assert.ok(typeof serialized.user.serialized.emailVerified === 'boolean');
43 | assert.ok(typeof serialized.user.serialized.uid === 'string');
44 | });
45 |
46 | test('toJSON', async function(assert) {
47 | let json = this.auth.toJSON();
48 | assert.deepEqual(json, {
49 | instance: json.instance,
50 | serialized: {
51 | user: null
52 | }
53 | });
54 | assert.ok(json.instance.startsWith('zuglet@store/auth::ember'));
55 | });
56 |
57 | });
58 |
--------------------------------------------------------------------------------
/tests/dummy/app/models/docs/page.js:
--------------------------------------------------------------------------------
1 | import { setOwner } from '@ember/application';
2 | import { reads } from "macro-decorators";
3 | import { cached } from "tracked-toolbox";
4 | import { remark } from 'remark/decorators';
5 |
6 | const withoutExtension = fn => (target, key) => cached(target, key, {
7 | get() {
8 | let components = fn.call(this, this).split('.');
9 | components.pop();
10 | return components.join('.');
11 | }
12 | });
13 |
14 | export default class Page {
15 |
16 | constructor(owner, { docs, file }) {
17 | setOwner(this, owner);
18 | this.docs = docs;
19 | this.file = file;
20 | }
21 |
22 | @reads('file.attributes.pos') pos;
23 | @reads('file.attributes.hidden') hidden;
24 | @reads('file.body') body;
25 | @reads('file.filename') filename;
26 | @reads('file.directory') directory;
27 |
28 | @withoutExtension(page => page.file.name) id;
29 | @withoutExtension(page => page.filename) name;
30 |
31 | get pages() {
32 | return this.docs.directory(this.id);
33 | }
34 |
35 | @cached
36 | get title() {
37 | let { file } = this;
38 | return file.attributes.title || file.toc[0]?.content || this.name;
39 | }
40 |
41 | @remark('body')
42 | tree(node) {
43 | if(node.tagName === 'a') {
44 | let href = node.properties.href;
45 | if(href.startsWith('http:') || href.startsWith('https:') || href.startsWith('mailto:')) {
46 | node.properties.target = 'top';
47 | } else if(href.startsWith('api/')) {
48 | return {
49 | type: 'component',
50 | name: 'block/remark/link-to',
51 | inline: true,
52 | model: {
53 | route: 'docs.page',
54 | model: href
55 | },
56 | children: node.children
57 | };
58 | } else {
59 | console.log('Unmapped link', node);
60 | }
61 | }
62 | return node;
63 | }
64 |
65 | async load() {
66 | await this.file.load();
67 | await this.tree.load();
68 | return this;
69 | }
70 |
71 | }
72 |
--------------------------------------------------------------------------------
/docs/api/models.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Models
3 | pos: 2
4 | ---
5 |
6 | # Models
7 |
8 | A simple wrapper around Ember's `getOwner(this).getFactory(…)` which works only with `model:…` registrations.
9 |
10 | ``` javascript
11 | let models = store.models;
12 | ```
13 |
14 | ## create(name, ...args) `→ instance`
15 |
16 | Creates a new model instance for given factory name and properties.
17 |
18 | ### EmberObject
19 |
20 | ``` javascript
21 | // app/models/message.js
22 | export default class Message extends EmberObject {
23 | }
24 | ```
25 |
26 | ``` javascript
27 | let model = models.create('message', { from: 'larry', to: 'zeeba' });
28 | model.from // → 'larry'
29 | model.to // → 'zeeba'
30 | ```
31 |
32 | ### Plain ES6 Class
33 |
34 | ``` javascript
35 | // app/models/message.js
36 | import { setOwner } from '@ember/application';
37 |
38 | export default class Message {
39 | constructor(owner, from, to) {
40 | setOwner(this, owner); // owner → `getOwner(this)`
41 | this.from = from;
42 | this.to = to;
43 | }
44 | }
45 | ```
46 |
47 | ``` javascript
48 | let model = models.create('message', 'larry', 'zeeba');
49 | model.from // → 'larry'
50 | model.to // → 'zeeba'
51 | ```
52 |
53 | ## Plain ZugletObject ES6 class
54 |
55 | `ZugletObject` sets owner and overrides `toString()`.
56 |
57 | ``` javascript
58 | // app/models/message.js
59 | import ZugletObject from 'zuglet/object';
60 |
61 | export default class Message {
62 | constructor(owner, from, to) {
63 | super(owner);
64 | this.from = from;
65 | this.to = to;
66 | }
67 | }
68 | ```
69 |
70 | ``` javascript
71 | let model = models.create('message', 'larry', 'zeeba');
72 | model.from // → 'larry'
73 | model.to // → 'zeeba'
74 | ```
75 |
76 | ## factoryFor(name, { optional }) `→ factory or undefined`
77 |
78 | * `optional` → boolean, defaults to false
79 |
80 | Lookups model factory for name.
81 |
82 | If `optional` is false and factory is not registered, assertation error is thrown.
83 |
84 | ## registerFactory(name, factory) `→ undefined`
85 |
86 | Registers model factory
87 |
--------------------------------------------------------------------------------
/addon/components/zuglet/stats.hbs:
--------------------------------------------------------------------------------
1 | ember install {{this.config.name}}
6 | Ember.js Octane addon for effortless Firebase integration.
7 | 33 | This addon is built and maintained by Arnis Vuskans, 34 | contact me at ampatspell@gmail.com for Ember.js and Firebase consulting. 35 |
36 |
2 | {{#if this.showStores}}
3 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # ember-cli-zuglet  [](https://badge.fury.io/js/ember-cli-zuglet)
2 |
3 | This addon is dead simple way to use Google Firebase services in your Ember.js apps. Cloud Firestore, Storage, Auth, Functions.
4 |
5 | **[ember-cli-zuglet is built and maintained by Arnis Vuskans, contact me for Ember.js, ember-cli-zuglet and Google Firebase consulting](https://www.amateurinmotion.com/)**.
6 |
7 | ember-cli-zuglet@^2.0.0 is a complete rewrite for Ember.js Octane edition.
8 |
9 | * [Website](https://www.ember-cli-zuglet.com/)
10 | * [Documentation](https://www.ember-cli-zuglet.com/docs)
11 |
12 | Open source apps built using ember-cli-zuglet:
13 |
14 | * [kaste](https://github.com/ampatspell/kaste)
15 | * [dzeja](https://github.com/ampatspell/dzeja)
16 | * Pre-octane Ember.js & ember-cli-zuglet v1.x
17 | * [tiny](http://github.com/ampatspell/tiny)
18 | * [bain ×](https://getbain.com/)
19 | * [index65](https://github.com/ampatspell/index65)
20 | * [ohne-zeit](https://github.com/ampatspell/ohne-zeit)
21 |
22 | ## Install
23 |
24 | ``` bash
25 | $ ember new foof --skip-npm
26 | ```
27 |
28 | ``` diff
29 | "devDependencies": {
30 | - "ember-data": "~3.22.0",
31 | }
32 | ```
33 |
34 | ``` bash
35 | $ ember install ember-cli-zuglet
36 | ```
37 |
38 | Open `app/store.js` and add your Firebase config.
39 |
40 | ## Documentation
41 |
42 | See the [ember-cli-zuglet website](https://www.ember-cli-zuglet.com) for documentation and [dummy app](https://github.com/ampatspell/ember-cli-zuglet/tree/master/tests/dummy/app/components/route/playground) for examples.
43 |
44 | ## Tweaks
45 |
46 | ``` javascript
47 | // jsconfig.json
48 | {
49 | "compilerOptions": {
50 | "target": "es6",
51 | "experimentalDecorators": true
52 | },
53 | "exclude": [ "node_modules", ".git" ]
54 | }
55 | ```
56 |
57 | ## Other useful addons to install
58 |
59 | ``` bash
60 | $ ember install tracked-toolbox
61 | $ ember install macro-decorators
62 | ```
63 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/route/playground/auth.hbs:
--------------------------------------------------------------------------------
1 |
4 | {{#if this.hasSingleStore}}
5 |
19 | {{/if}}
20 |
6 |
8 | {{else}}
9 | {{this.firstStore}}
7 | Stores
10 |
11 | {{#each this.stores as |model|}}
12 |
17 | {{/if}}
18 | {{model}}
13 | {{else}}
14 | No Stores
15 | {{/each}}
16 |
21 |
30 | Activated ({{this.stats.activated.length}})
22 |
23 | {{#each this.stats.activated as |model|}}
24 |
29 | {{model}}
25 | {{else}}
26 | No activated models
27 | {{/each}}
28 |
31 |
40 | Observers ({{this.stats.observers.length}})
32 |
33 | {{#each this.stats.observers as |model|}}
34 |
39 | {{model}}
35 | {{else}}
36 | No onSnapshot listeners
37 | {{/each}}
38 |
41 |
50 | Promises ({{this.stats.promises.length}})
42 |
43 | {{#each this.stats.promises as |promise|}}
44 |
49 | {{promise.stats.label}} : {{promise.stats.model}}
45 | {{else}}
46 | No promises
47 | {{/each}}
48 |
2 |
3 | {{#if this.error}}
4 |
--------------------------------------------------------------------------------
5 |
8 | {{/if}}
9 |
10 | {{#if this.store.auth.user}}
11 | Error
6 | {{this.error}}
7 |
12 |
13 |
14 | {{#if this.store.auth.user.photoURL}}
15 |
16 | 
17 |
18 | {{/if}}
19 | {{else}}
20 |
21 | Signed out
22 |
23 | {{/if}}
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 | {{#if this.store.auth.user.isAnonymous}}
32 |
33 | {{/if}}
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
54 |
55 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
56 |
63 |
64 |
57 |
58 |
59 |
60 |
61 |
62 |