build

Author: phortx

dist/actions/action.d.ts

@@ -0,0 +1,49 @@
+import { Arguments, Data, DispatchFunction } from "../support/interfaces";
+import Model from "../orm/model";
+import RootState from "@vuex-orm/core/lib/modules/contracts/RootState";
+/**
+ * Base class for all Vuex actions. Contains some utility and convenience methods.
+ */
+export default class Action {
+    /**
+     * Sends a mutation.
+     *
+     * @param {string} name Name of the mutation like 'createUser'
+     * @param {Data | undefined} variables Variables to send with the mutation
+     * @param {Function} dispatch Vuex Dispatch method for the model
+     * @param {Model} model The model this mutation affects.
+     * @param {boolean} multiple Tells if we're requesting a single record or multiple.
+     * @returns {Promise<any>}
+     */
+    protected static mutation(name: string, variables: Data | undefined, dispatch: DispatchFunction, model: Model): Promise<any>;
+    /**
+     * Convenience method to get the model from the state.
+     * @param {RootState} state Vuex state
+     * @returns {Model}
+     */
+    static getModelFromState(state: RootState): Model;
+    /**
+     * Makes sure args is a hash.
+     *
+     * @param {Arguments|undefined} args
+     * @param {any} id When not undefined, it's added to the args
+     * @returns {Arguments}
+     */
+    static prepareArgs(args?: Arguments, id?: any): Arguments;
+    /**
+     * Adds the record itself to the args and sends it through transformOutgoingData. Key is named by the singular name
+     * of the model.
+     *
+     * @param {Arguments} args
+     * @param {Model} model
+     * @param {Data} data
+     * @returns {Arguments}
+     */
+    static addRecordToArgs(args: Arguments, model: Model, data: Data): Arguments;
+    /**
+     * Transforms each field of the args which contains a model.
+     * @param {Arguments} args
+     * @returns {Arguments}
+     */
+    protected static transformArgs(args: Arguments): Arguments;
+}

dist/actions/destroy.d.ts

@@ -0,0 +1,14 @@
+import { ActionParams } from "../support/interfaces";
+import Action from "./action";
+/**
+ * Destroy action for sending a delete mutation. Will be used for record.$destroy().
+ */
+export default class Destroy extends Action {
+    /**
+     * @param {State} state The Vuex state
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {string} id ID of the record to delete
+     * @returns {Promise<any>} true
+     */
+    static call({ state, dispatch }: ActionParams, { id, args }: ActionParams): Promise<boolean>;
+}

dist/actions/fetch.d.ts

@@ -0,0 +1,14 @@
+import { ActionParams, Data } from "../support/interfaces";
+import Action from "./action";
+/**
+ * Fetch action for sending a query. Will be used for Model.fetch().
+ */
+export default class Fetch extends Action {
+    /**
+     * @param {any} state The Vuex state
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {ActionParams} params Optional params to send with the query
+     * @returns {Promise<Data>} The fetched records as hash
+     */
+    static call({ state, dispatch }: ActionParams, params?: ActionParams): Promise<Data>;
+}

dist/actions/index.d.ts

@@ -0,0 +1,7 @@
+import Action from './action';
+import Destroy from './destroy';
+import Fetch from './fetch';
+import Mutate from './mutate';
+import Persist from './persist';
+import Push from './push';
+export { Action, Destroy, Fetch, Mutate, Persist, Push };

dist/actions/mutate.d.ts

@@ -0,0 +1,16 @@
+import { ActionParams, Data } from "../support/interfaces";
+import Action from "./action";
+/**
+ * Mutate action for sending a custom mutation. Will be used for Model.mutate() and record.$mutate().
+ */
+export default class Mutate extends Action {
+    /**
+     * @param {any} state The Vuex state
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {string} name Name of the query
+     * @param {boolean} multiple Fetch one or multiple?
+     * @param {Arguments} args Arguments for the mutation. Must contain a 'mutation' field.
+     * @returns {Promise<Data>} The new record if any
+     */
+    static call({ state, dispatch }: ActionParams, { args, name }: ActionParams): Promise<Data>;
+}

dist/actions/persist.d.ts

@@ -0,0 +1,23 @@
+import { ActionParams, Data } from "../support/interfaces";
+import Action from "./action";
+/**
+ * Persist action for sending a create mutation. Will be used for record.$persist().
+ */
+export default class Persist extends Action {
+    /**
+     * @param {any} state The Vuex state
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {string} id ID of the record to persist
+     * @returns {Promise<Data>} The saved record
+     */
+    static call({ state, dispatch }: ActionParams, { id, args }: ActionParams): Promise<Data>;
+    /**
+     * It's very likely that the server generated different ID for this record.
+     * In this case Action.mutation has inserted a new record instead of updating the existing one.
+     *
+     * @param {Model} model
+     * @param {Data} record
+     * @returns {Promise<void>}
+     */
+    private static deleteObsoleteRecord;
+}

dist/actions/push.d.ts

@@ -0,0 +1,15 @@
+import { ActionParams, Data } from "../support/interfaces";
+import Action from "./action";
+/**
+ * Push action for sending a update mutation. Will be used for record.$push().
+ */
+export default class Push extends Action {
+    /**
+     * @param {any} state The Vuex state
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {Arguments} data New data to save
+     * @param {Arguments} args Additional arguments
+     * @returns {Promise<Data>} The updated record
+     */
+    static call({ state, dispatch }: ActionParams, { data, args }: ActionParams): Promise<Data>;
+}

dist/actions/query.d.ts

@@ -0,0 +1,17 @@
+import { ActionParams, Data } from "../support/interfaces";
+import Action from "./action";
+/**
+ * Query action for sending a custom query. Will be used for Model.customQuery() and record.$customQuery.
+ */
+export default class Query extends Action {
+    /**
+     * @param {any} state The Vuex state
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {string} name Name of the query
+     * @param {boolean} multiple Fetch one or multiple?
+     * @param {object} filter Filter object (arguments)
+     * @param {boolean} bypassCache Whether to bypass the cache
+     * @returns {Promise<Data>} The fetched records as hash
+     */
+    static call({ state, dispatch }: ActionParams, { name, filter, bypassCache }: ActionParams): Promise<Data>;
+}

dist/actions/simple-mutation.d.ts

@@ -0,0 +1,14 @@
+import { ActionParams } from "../support/interfaces";
+import Action from "./action";
+/**
+ * SimpleMutation action for sending a model unrelated simple mutation.
+ */
+export default class SimpleMutation extends Action {
+    /**
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {string} query The query to send
+     * @param {Arguments} variables
+     * @returns {Promise<any>} The result
+     */
+    static call({ dispatch }: ActionParams, { query, variables }: ActionParams): Promise<any>;
+}

dist/actions/simple-query.d.ts

@@ -0,0 +1,15 @@
+import { ActionParams } from "../support/interfaces";
+import Action from "./action";
+/**
+ * SimpleQuery action for sending a model unrelated simple query.
+ */
+export default class SimpleQuery extends Action {
+    /**
+     * @param {DispatchFunction} dispatch Vuex Dispatch method for the model
+     * @param {string} query The query to send
+     * @param {Arguments} variables
+     * @param {boolean} bypassCache Whether to bypass the cache
+     * @returns {Promise<any>} The result
+     */
+    static call({ dispatch }: ActionParams, { query, bypassCache, variables }: ActionParams): Promise<any>;
+}

dist/adapters/adapter.d.ts

@@ -0,0 +1,24 @@
+import Model from "../orm/model";
+export declare enum ConnectionMode {
+    AUTO = 0,
+    PLAIN = 1,
+    NODES = 2,
+    EDGES = 3
+}
+export declare enum ArgumentMode {
+    TYPE = 0,
+    LIST = 1
+}
+export default interface Adapter {
+    getRootQueryName(): string;
+    getRootMutationName(): string;
+    getNameForPersist(model: Model): string;
+    getNameForPush(model: Model): string;
+    getNameForDestroy(model: Model): string;
+    getNameForFetch(model: Model, plural: boolean): string;
+    getConnectionMode(): ConnectionMode;
+    getArgumentMode(): ArgumentMode;
+    getFilterTypeName(model: Model): string;
+    getInputTypeName(model: Model, action?: string): string;
+    prepareSchemaTypeName(name: string): string;
+}

dist/adapters/builtin/default-adapter.d.ts

@@ -0,0 +1,15 @@
+import Adapter, { ConnectionMode, ArgumentMode } from "../adapter";
+import Model from "../../orm/model";
+export default class DefaultAdapter implements Adapter {
+    getRootMutationName(): string;
+    getRootQueryName(): string;
+    getConnectionMode(): ConnectionMode;
+    getArgumentMode(): ArgumentMode;
+    getFilterTypeName(model: Model): string;
+    getInputTypeName(model: Model, action?: string): string;
+    getNameForDestroy(model: Model): string;
+    getNameForFetch(model: Model, plural: boolean): string;
+    getNameForPersist(model: Model): string;
+    getNameForPush(model: Model): string;
+    prepareSchemaTypeName(name: string): string;
+}

dist/common/context.d.ts

@@ -0,0 +1,139 @@
+import Logger from "./logger";
+import Model from "../orm/model";
+import { PluginComponents } from "@vuex-orm/core/lib/plugins/use";
+import Apollo from "../graphql/apollo";
+import Database from "@vuex-orm/core/lib/database/Database";
+import { Options } from "../support/interfaces";
+import Schema from "../graphql/schema";
+import { Mock, MockOptions } from "../test-utils";
+import Adapter, { ConnectionMode } from "../adapters/adapter";
+/**
+ * Internal context of the plugin. This class contains all information, the models, database, logger and so on.
+ *
+ * It's a singleton class, so just call Context.getInstance() anywhere you need the context.
+ */
+export default class Context {
+    /**
+     * Contains the instance for the singleton pattern.
+     * @type {Context}
+     */
+    static instance: Context;
+    /**
+     * Components collection of Vuex-ORM
+     * @type {PluginComponents}
+     */
+    readonly components: PluginComponents;
+    /**
+     * The options which have been passed to VuexOrm.install
+     * @type {Options}
+     */
+    readonly options: Options;
+    /**
+     * GraphQL Adapter.
+     * @type {Adapter}
+     */
+    readonly adapter: Adapter;
+    /**
+     * The Vuex-ORM database
+     * @type {Database}
+     */
+    readonly database: Database;
+    /**
+     * Collection of all Vuex-ORM models wrapped in a Model instance.
+     * @type {Map<any, any>}
+     */
+    readonly models: Map<string, Model>;
+    /**
+     * When true, the logging is enabled.
+     * @type {boolean}
+     */
+    readonly debugMode: boolean;
+    /**
+     * Our nice Vuex-ORM-GraphQL logger
+     * @type {Logger}
+     */
+    readonly logger: Logger;
+    /**
+     * Instance of Apollo which cares about the communication with the graphql endpoint.
+     * @type {Apollo}
+     */
+    apollo: Apollo;
+    /**
+     * The graphql schema. Is null until the first request.
+     * @type {Schema}
+     */
+    schema: Schema | undefined;
+    /**
+     * Tells if the schema is already loaded or the loading is currently processed.
+     * @type {boolean}
+     */
+    private schemaWillBeLoaded;
+    /**
+     * Defines how to query connections. 'auto' | 'nodes' | 'edges' | 'plain'
+     */
+    connectionMode: ConnectionMode;
+    /**
+     * Container for the global mocks.
+     * @type {Object}
+     */
+    private globalMocks;
+    /**
+     * Private constructor, called by the setup method
+     *
+     * @constructor
+     * @param {PluginComponents} components The Vuex-ORM Components collection
+     * @param {Options} options The options passed to VuexORM.install
+     */
+    private constructor();
+    /**
+     * Get the singleton instance of the context.
+     * @returns {Context}
+     */
+    static getInstance(): Context;
+    /**
+     * This is called only once and creates a new instance of the Context.
+     * @param {PluginComponents} components The Vuex-ORM Components collection
+     * @param {Options} options The options passed to VuexORM.install
+     * @returns {Context}
+     */
+    static setup(components: PluginComponents, options: Options): Context;
+    loadSchema(): Promise<Schema>;
+    processSchema(): void;
+    /**
+     * Returns a model from the model collection by it's name
+     *
+     * @param {Model|string} model A Model instance, a singular or plural name of the model
+     * @param {boolean} allowNull When true this method returns null instead of throwing an exception when no model was
+     *                            found. Default is false
+     * @returns {Model}
+     */
+    getModel(model: Model | string, allowNull?: boolean): Model;
+    /**
+     * Will add a mock for simple mutations or queries. These are model unrelated and have to be
+     * handled  globally.
+     *
+     * @param {Mock} mock - Mock config.
+     */
+    addGlobalMock(mock: Mock): boolean;
+    /**
+     * Finds a global mock for the given action and options.
+     *
+     * @param {string} action - Name of the action like 'simpleQuery' or 'simpleMutation'.
+     * @param {MockOptions} options - MockOptions like { name: 'example' }.
+     * @returns {Mock | null} null when no mock was found.
+     */
+    findGlobalMock(action: string, options: MockOptions | undefined): Mock | null;
+    /**
+     * Hook to be called by simpleMutation and simpleQuery actions in order to get the global mock
+     * returnValue.
+     *
+     * @param {string} action - Name of the action like 'simpleQuery' or 'simpleMutation'.
+     * @param {MockOptions} options - MockOptions.
+     * @returns {any} null when no mock was found.
+     */
+    globalMockHook(action: string, options: MockOptions): any;
+    /**
+     * Wraps all Vuex-ORM entities in a Model object and saves them into this.models
+     */
+    private collectModels;
+}