├── .gitignore
├── CHANGELOG.md
├── LICENSE.txt
├── README.md
├── both.js
├── client-collection.js
├── client-connector.js
├── client.js
├── package.js
├── package.json
├── server-collection.js
├── server-connector.js
└── server.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | All notable changes to this project will be documented in this file.
 3 | 
 4 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 5 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 6 | 
 7 | ## [0.2.1]
 8 | - Increment required versions to the latest.
 9 | 
10 | ## [0.2.0]
11 | - Change `createListHook` to `createConnector`. The method still returns a react hook, but it also does other things like setting up server methods. It can now set up a single document data query. For these reasons, a more general name is appropriate.
12 | - Add a `single` configuration property, to create a connector for a single document.
13 | - Always call `validate` before `run` on server and client.
14 | - No need to run through `useTracker` in server rendering.
15 | - Switched to official `react-meteor-data` hook implementation.
16 | - No longer export `useTracker` - users must migrate to import from `meteor:react-meteor-data`.
17 | 
18 | ## [0.1.3]
19 | - Fix error with importing useTracker correctly after making a local copy.
20 | 
21 | ## [0.1.2]
22 | - Include a copy of `useTracker` until the official package is released. This will be removed at some point, please don't rely on it.
23 | 
24 | ## [0.1.1]
25 | - **Breaking change**: Changed the format of the return data from an object with data, and loading props named after the connector name or nameProp value, to a tuple. Much simpler, and more flexible, but a breaking change from 0.1.0.
26 | 
27 | ## [0.1.0]
28 | - First version!
29 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Kevin Newman
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | NP Dev Collections
  2 | ==========================
  3 | 
  4 | Foundational code for NP Dev Collections was generously donated by [PixStori](https://www.pixstoriplus.com), an aural history social media tool built on Meteor. Tell your stori.
  5 | 
  6 | NPDev Collections combines a mix of technologies to facilitate the creation of offline first collections, data over methods with pagination, and support for SSR out of the box.
  7 | 
  8 | Install with:
  9 | 
 10 | `$ meteor add npdev:collections`
 11 | 
 12 | [Check out my starter](https://github.com/CaptainN/meteor-react-starter) for a complete example site using NP Dev Collections and other server-render tools.
 13 | 
 14 | Why
 15 | ---
 16 | 
 17 | Basically, I like Mongo and MiniMongo for it's low bar for entry, and it's simple iteration. It's great for starting new projects and prototyping early and rapidly. I wanted to create something that added a few of the modern touches, like offline-first data, and server side rendering, while retaining that wonderful simplicity as much as possible.
 18 | 
 19 | What
 20 | ----
 21 | 
 22 | There are a lot moving parts involved getting all the parts working together. Here are some of the hurdles:
 23 | 
 24 | - Use offline storage client side by default. `ground:db` is a great solution.
 25 | - SSR - for SSR, we have a number of tricky parts to choreograph.
 26 |   - Query Mongo directly, and avoid setting up subscriptions.
 27 |   - Capture the results of queries on the server during SSR, and serialize that data to send to the client.
 28 |   - Hydrate the data from the server on the client, before rendering the react tree.
 29 |   - On first render, don't fetch remote data - we just got that through hydration.
 30 |   - Those same queries must work in an isomorphic way - on the server they must run against mongo directly, on the client, they must fetch data.
 31 | - Use methods for data transfer by default, instead of reactive pub/sub (on the list of TODOs is to allow pub/sub instead of methods).
 32 |   - Also provide a method of pagination by default in the methods.
 33 | 
 34 | That's a lot of stuff to keep track of, and it's kind of a pain to do it manually. NPDev;Collections keep track of all that for you, and provides the tools to easily set it all up.
 35 | 
 36 | How
 37 | ---
 38 | 
 39 | - We'll use mongo queries on the server and client, in an isomorphic way. NPDev:Collections provides a createCollection method with a single import location, which delivers Mongo on the server, and GroundDB on the client. This keeps the code isomorphic, and canonical. The server will use Mongo directly, and never display a loading screen.
 40 | - On the server, during SSR, we'll capture all query data, and output it as JSON (actually, EJSON) for hydration to use. This is done with a Context Provider, and a utility method, which must be configured in SSR code using Meteor's `server-render` package.
 41 | - On the client, that data gets hydrated before React is hydrated. We also have to make sure there is no attempt to hit the server to grab data in the first render, since we already got the data. This is accomplished through another simple Provider, and a utility method, which must be configured in the client side React startup code. First hydrate the data, then hydrate react.
 42 | - After the first run (during hydration), the client will fetch data via meteor methods. The isLoading property will only be true during syncing (loading) events.
 43 | 
 44 | Quick Start!
 45 | ------------
 46 | 
 47 | Install with:
 48 | 
 49 | `meteor add npdev:collections`
 50 | 
 51 | We also need react and react-dom npm packages of course. These are not defined in this package, so that the version can be kept up to date in the main project. This package requires a version of react which contains support for hooks - 16.8+.
 52 | 
 53 | The first thing we need are our collections. They can be created using the simple `createCollection` method. All this is does is create a Meteor Collection on the server, or a Ground:DB server on the client, and connect the schema using `aldeed:collection2`'s attachSchema (on the server). It's necessary to use this method to create your collections to register them with NPDev:Collections. I'll probably add some facilities to allow more granular control over these in the future. Of course, these collections should all be included in the server bundle.
 54 | 
 55 | ```js
 56 | import { createCollection } from 'meteor/npdev:collections'
 57 | import { CommentSchema } from './CommentSchema'
 58 | 
 59 | const Comments = createCollection('comments', CommentSchema)
 60 | 
 61 | export default Comments
 62 | ```
 63 | 
 64 | Basic use requires the creation of custom hooks for each query you want to set up. The `createConnector` utility function accept a set of properties - name, collection, an isomorphic validation method, and an isomorphic query generator. This API is inspired by, and builds on the API of mdg:validated-method. Here is an example from PixStori:
 65 | 
 66 | ```js
 67 | import { createListHood } from 'meteor/npdev:collections'
 68 | 
 69 | // getPublicQuery builds a query which selects the appropriate public documents
 70 | const getPublicQuery = () => ({
 71 |   public: true
 72 | })
 73 | 
 74 | export const useComments = createConnector({
 75 |   name: 'tiles',
 76 |   collection: Comments,
 77 |   // This runs on client and server, and in both methods and SSR contexts.
 78 |   validate () {},
 79 |   // So does this! Be careful with security.
 80 |   query () {
 81 |     return getPublicQuery()
 82 |   }
 83 | })
 84 | 
 85 | export const useGroupComments = createConnector({
 86 |   name: 'groupComments',
 87 |   collection: Comments,
 88 |   validate ({ groupId }) {
 89 |     // Here we could use SimpleSchema and/or throw a validated-error, etc.
 90 |     // See the ValidateMethod documentation for more.
 91 |     check(groupId, String)
 92 |   },
 93 |   query: ({ groupId }) => ({
 94 |     $and: [
 95 |       { groupId },
 96 |       getPublicQuery()
 97 |     ]
 98 |   })
 99 | })
100 | 
101 | ```
102 | 
103 | **NOTE:** *These hooks must be included in the server build, not just in the react tree, but somewhere statically, so they can set up the necessary methods. They don't need to be included statically in the client bundle, which allows for code splitting using the `dynamic-import` package.*
104 | 
105 | Using this, along with `createConnector`, it sets up everything we need on the server, and on the client to do offline-first, data-over-methods, with pagination, and SSR, with data hydration, etc. (along with using a set of providers in SSR and hydration code). Super spiffy! In use, it looks like this:
106 | 
107 | ```js
108 | // Here we use the group comments.
109 | const GroupFeedPage = ({ limit, offset, order, orderBy, groupId }) => {
110 |   const [ groupComments, groupCommentsAreLoading ] = useGroupComments({ groupId, limit, offset, order, orderBy })
111 |   return <FeedPage tiles={groupComments} isLoading={groupCommentsAreLoading} />
112 | }
113 | ```
114 | 
115 | That's already a pretty easy way to grab data! But we also want to have SSR with data hydration.
116 | 
117 | ```js
118 | import React from 'react'
119 | import { StaticRouter } from 'react-router'
120 | import { renderToString } from 'react-dom/server'
121 | import { onPageLoad } from 'meteor/server-render'
122 | import App from '/imports/App'
123 | import { DataCaptureProvider } from 'meteor/npdev:collections'
124 | 
125 | onPageLoad(sink => {
126 |   const context = {}
127 | 
128 |   // use the DataCaptureProvider with a scoped dataHandle
129 |   const dataHandle = {}
130 |   const app = <DataCaptureProvider handle={dataHandle}>
131 |     <StaticRouter location={sink.request.url} context={context}>
132 |       <App />
133 |     </StaticRouter>
134 |   </DataCaptureProvider>
135 | 
136 |   // render the app to html
137 |   const content = renderToString(app)
138 | 
139 |   // render out the html
140 |   sink.renderIntoElementById('root', content)
141 | 
142 |   // render out the captured data
143 |   sink.appendToBody(dataHandle.toScriptTag())
144 | })
145 | ```
146 | 
147 | Behind the scenes this provider is watching for all the queries that happen during rendering of the current route, and captures that data in a property on `dataHandle`. Then the `toScriptTag` method is used to render out a `<script>` tag which contains an EJSON encoded copy of all that data. This will be hydrated on the client side, like so:
148 | 
149 | ```js
150 | import { onPageLoad } from 'meteor/server-render'
151 | 
152 | onPageLoad(sink => {
153 |   import React from 'react'
154 |   import { hydrate } from 'react-dom'
155 |   import { BrowserRouter } from 'react-router-dom'
156 |   import { DataHydrationProvider, hydrateData } from 'meteor/npdev:collections'
157 |   import App from '/imports/App'
158 | 
159 |   // Load the data into offline storage
160 |   hydrateData()
161 | 
162 |   // The isHydrating flag basically tells the hooks not to bother loading data
163 |   // over methods, since we just hydrated all the data above.
164 |   const hydrationHandle = { isHydrating: true }
165 | 
166 |   const app = <DataHydrationProvider handle={hydrationHandle}>
167 |     <BrowserRouter>
168 |       <App />
169 |     </BrowserRouter>
170 |   </DataHydrationProvider>
171 | 
172 |   // hydrate the app using React.hydrate (<div id="root"></div> defined using
173 |   // static-html package in /client/main.html)
174 |   hydrate(app, document.getElementById('root'), () => {
175 |     // set the isHydrating flag to false, so that subsequent renders will know
176 |     // to fetch data.
177 |     hydrationHandle.isHydrating = false
178 |   })
179 | })
180 | ```
181 | 
182 | TODOS:
183 | ------
184 | 
185 | - Optimize the sync algorithm. It's not much of an algorithm at all right now - it just does a simple load on mount, with no real smarts. At the very least it'd be a good idea to use a Flux patterned, global action controller, which would limit the frequency of similar remote queries.
186 |   - If we have offline data already, maybe we can send a list of lastModified timestamps, and only return changed documents.
187 | - Use a Provider/Consumer for cases where the same connector is used in multiple spots in the tree. This could reduce the stress on mini mongo.
188 |   - This might be easy enough for an end user to set up that an example is all that we need.
189 | - Figure out a way to anchor the pagination off the first doc we get back on the first page.
190 |   - After the above, also figure out a way to get notice of newer documents (add some meta data to a paged dataset).
191 | - Add an offline property to the connector config object. If it's set to false, it would use an in memory cache only, and no Ground DB.
192 | - Add a live property to the connector config object. If set, it would set up a pub/sub connection (with a monitoring Ground DB) instead of data over methods.
193 | - Add a pagination property to the connector config object. If set to false, we'll skip pagination flags altogether.
194 |   - Maybe we can just set the limit prop to -1 for this case.
195 | - Add tools (maybe in a sibling package) to enable accounts in SSR.
196 | 
197 | You can find some of the SSR stuff here (without the data part for now), in [my starter repo](https://github.com/CaptainN/meteor-react-starter).
198 | 


--------------------------------------------------------------------------------
/both.js:
--------------------------------------------------------------------------------
 1 | /* global check, ValidatedMethod */
 2 | 
 3 | export const makePagedRun = (collection, query) => ({ limit = 5, offset = 0, order = -1, orderBy = 'createdAt', ...rest }) => (
 4 |   collection.find(query(rest), {
 5 |     limit,
 6 |     skip: offset,
 7 |     sort: {
 8 |       [orderBy]: order
 9 |     }
10 |   }).fetch()
11 | )
12 | 
13 | export const makeSingleRun = (collection, query) => (args) => (
14 |   collection.findOne(query(args))
15 | )
16 | 
17 | export const makeDataMethod = (name, validate, run) => new ValidatedMethod({
18 |   name: 'pixdata:' + name,
19 |   validate ({ limit = 5, offset = 0, order = -1, orderBy = 'createdAt', ...rest }) {
20 |     check(limit, Number)
21 |     check(offset, Number)
22 |     check(order, Number)
23 |     check(orderBy, String)
24 |     validate(rest)
25 |   },
26 |   run
27 | })
28 | 
29 | export const makePruneMethod = (name, collection, validate, query) => new ValidatedMethod({
30 |   name: `pixdata:${name}:checkExtant`,
31 |   validate ({ IDs, limit = 5, offset = 0, order = -1, orderBy = 'createdAt', ...rest }) {
32 |     // We're mostly pulling out the
33 |     check(limit, Number)
34 |     check(offset, Number)
35 |     check(order, Number)
36 |     check(orderBy, String)
37 |     check(IDs, [String])
38 |     validate(rest)
39 |   },
40 |   run (args) {
41 |     const { IDs } = args
42 |     // Find all documents in provided list, then match the missing ones
43 |     const extantDocs = collection.find({
44 |       $and: [
45 |         { _id: { $in: IDs } },
46 |         query(args)
47 |       ]
48 |     }, { fields: { _id: 1 } }).fetch()
49 |     const extantIDs = extantDocs.map(doc => doc._id)
50 |     const deletedIDs = IDs.filter((idToCheck) => !extantIDs.includes(idToCheck))
51 |     return deletedIDs
52 |   }
53 | })
54 | 


--------------------------------------------------------------------------------
/client-collection.js:
--------------------------------------------------------------------------------
 1 | import { Ground } from 'meteor/ground:db'
 2 | 
 3 | const collectionRegistry = {}
 4 | export const createCollection = (name, schema, indexes = []) => {
 5 |   if (collectionRegistry[name]) {
 6 |     return collectionRegistry[name]
 7 |   }
 8 | 
 9 |   const OfflineCollection = new Ground.Collection(name)
10 |   collectionRegistry[name] = OfflineCollection
11 | 
12 |   return OfflineCollection
13 | }
14 | 
15 | export const getCollectionByName = (name) => createCollection(name)
16 | 


--------------------------------------------------------------------------------
/client-connector.js:
--------------------------------------------------------------------------------
  1 | /* global Meteor */
  2 | import React, { createContext, useState, useContext, useRef } from 'react'
  3 | import { EJSON } from 'meteor/ejson'
  4 | import { useTracker } from 'meteor/react-meteor-data'
  5 | import { makePagedRun, makeSingleRun, makeDataMethod, makePruneMethod } from './both'
  6 | import { getCollectionByName } from './client-collection'
  7 | 
  8 | const ConnectorContext = createContext(false)
  9 | export const DataHydrationProvider = ({ handle, children }) => {
 10 |   // :TODO: Add some development mode checks to make sure user sets handle.isHydrating correctly
 11 |   /**
 12 |    * Handle should be passed by user in the shape of:
 13 |    * { isHydrating: true|false }
 14 |    */
 15 |   return <ConnectorContext.Provider value={handle}>
 16 |     {children}
 17 |   </ConnectorContext.Provider>
 18 | }
 19 | 
 20 | let requestCounter = 0
 21 | export const createConnector = ({ name, collection, validate, query, single = false }) => {
 22 |   const run = single
 23 |     ? makeSingleRun(collection, query)
 24 |     : makePagedRun(collection, query)
 25 |   const dataMethod = makeDataMethod(name, validate, run, query)
 26 |   const pruneMethod = makePruneMethod(name, collection, validate, query)
 27 | 
 28 |   return (args = {}, onLoad = null) => {
 29 |     const hydrationContext = useContext(ConnectorContext)
 30 |     const [isLoading, setIsLoading] = useState(false)
 31 |     const { current: refs } = useRef({
 32 |       requestId: requestCounter,
 33 |       onLoad: null,
 34 |       lastArgValues: null
 35 |     })
 36 | 
 37 |     // If onLoad is defined inline in the user (likely) it's ref will change with each render pass,
 38 |     // so we need to make sure we always have the latest one in the effect callback - but we don't
 39 |     // want to re-invoke the effect every time the reference changes, which is every time.
 40 |     refs.onLoad = onLoad
 41 | 
 42 |     // We only want to refetch data if `args` changes. We also need this to start synchronously,
 43 |     // so that we can correctly ascertain whether react is currently hydrating.
 44 |     const argValues = Object.values(args)
 45 | 
 46 |     // We don't need to load data, but we need to call onLoad with the correct documents from offline storage.
 47 |     // Data should already have been hydrated.
 48 |     if (hydrationContext.isHydrating) {
 49 |       if (refs.onLoad) {
 50 |         validate(args)
 51 |         const docs = run(args)
 52 |         refs.onLoad(docs)
 53 |       }
 54 |     } else if (!isLoading && !isArgsEqual(argValues, refs.lastArgValues)) {
 55 |       setIsLoading(true)
 56 | 
 57 |       deferPrune(pruneMethod, collection, query, args)
 58 | 
 59 |       // Capture requestId in scope, and compare to make sure a new request hasn't started before we're done
 60 |       const requestId = refs.requestId = requestCounter++
 61 |       dataMethod.call(args, (err, res) => {
 62 |         let docs
 63 |         if (err) {
 64 |           console.error(err)
 65 |           docs = []
 66 |         } else {
 67 |           docs = res
 68 |           if (single) {
 69 |             collection.upsert(docs._id, docs)
 70 |           } else {
 71 |             for (const doc of docs) {
 72 |               collection.upsert(doc._id, doc)
 73 |             }
 74 |           }
 75 |         }
 76 |         if (requestId === refs.requestId) {
 77 |           Meteor.defer(() => {
 78 |             if (requestId !== refs.requestId) {
 79 |               return
 80 |             }
 81 |             setIsLoading(false)
 82 |             if (refs.onLoad) {
 83 |               refs.onLoad(docs)
 84 |             }
 85 |           })
 86 |         }
 87 |       })
 88 |     }
 89 |     refs.lastArgValues = argValues
 90 | 
 91 |     return useTracker(() => {
 92 |       validate(args)
 93 |       return [run(args), isLoading]
 94 |     }, [isLoading, ...Object.values(args)])
 95 |   }
 96 | }
 97 | 
 98 | const deferPrune = (pruneMethod, collection, query, args) => Meteor.defer(() => {
 99 |   const allLocal = collection.find(query(args)).fetch()
100 |   const IDs = allLocal.map(doc => doc._id)
101 |   pruneMethod.call({ ...args, IDs }, (err, res) => {
102 |     if (err) {
103 |       console.error(err)
104 |       return
105 |     }
106 |     for (const id of res) {
107 |       collection.remove(id)
108 |     }
109 |   })
110 | })
111 | 
112 | // :TODO: use a prune method - probably store a lookup table like getCollectionByName
113 | export const hydrateData = (id = '__NPCollectionCaptureData__') => {
114 |   const collectionDataNode = document.getElementById(id)
115 |   if (collectionDataNode) {
116 |     const data = EJSON.parse(collectionDataNode.innerText)
117 |     updateCollections(data)
118 |     collectionDataNode.parentNode.removeChild(collectionDataNode)
119 |   }
120 | }
121 | export const updateCollections = (data) => {
122 |   const cols = []
123 |   for (const collectionData of data) {
124 |     const col = getCollectionByName(collectionData.name)
125 |     for (const doc of collectionData.docs) {
126 |       col.upsert(doc._id, doc)
127 |     }
128 |     cols.push(col)
129 |   }
130 | }
131 | 
132 | const is = (x, y) =>
133 |   (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
134 | 
135 | const isArgsEqual = (nextDeps, prevDeps) => {
136 |   if (!nextDeps || !prevDeps) {
137 |     return false
138 |   }
139 |   const len = nextDeps.length
140 |   if (prevDeps.length !== len) {
141 |     return false
142 |   }
143 |   for (let i = 0; i < len; i++) {
144 |     if (!is(nextDeps[i], prevDeps[i])) {
145 |       return false
146 |     }
147 |   }
148 |   return true
149 | }
150 | 


--------------------------------------------------------------------------------
/client.js:
--------------------------------------------------------------------------------
1 | export { createCollection, getCollectionByName } from './client-collection'
2 | export { DataHydrationProvider, createConnector, hydrateData, updateCollections } from './client-connector'
3 | 


--------------------------------------------------------------------------------
/package.js:
--------------------------------------------------------------------------------
 1 | /* global Package */
 2 | Package.describe({
 3 |   name: 'npdev:collections',
 4 |   summary: 'An easy way to create offline collections with SSR',
 5 |   description: 'An easy way to create offline collections with SSR',
 6 |   version: '0.2.1',
 7 |   git: 'https://github.com/CaptainN/npdev-collections'
 8 | })
 9 | 
10 | Package.onUse(function (api) {
11 |   api.versionsFrom([
12 |     'METEOR@1.5',
13 |     'METEOR@1.10'
14 |   ])
15 | 
16 |   api.use(['check', 'ecmascript', 'ejson'])
17 |   api.use('mdg:validated-method@1.2.0', ['client', 'server'])
18 |   api.use('ground:db@2.0.0', 'client')
19 |   api.use('mongo', 'server')
20 |   api.use('react-meteor-data@2.0.1', 'client')
21 | 
22 |   api.mainModule('client.js', 'client', { lazy: true })
23 |   api.mainModule('server.js', 'server', { lazy: true })
24 | })
25 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "npdev-collections",
 3 |   "devDependencies": {
 4 |     "babel-eslint": "^10.0.3",
 5 |     "eslint": "^6.2.2",
 6 |     "eslint-config-standard": "^14.1.0",
 7 |     "eslint-config-standard-jsx": "^8.1.0",
 8 |     "eslint-import-resolver-meteor": "^0.4.0",
 9 |     "eslint-plugin-import": "^2.18.2",
10 |     "eslint-plugin-meteor": "^6.0.0",
11 |     "eslint-plugin-node": "^9.2.0",
12 |     "eslint-plugin-promise": "^4.2.1",
13 |     "eslint-plugin-react": "^7.14.3",
14 |     "eslint-plugin-react-hooks": "^2.0.1",
15 |     "eslint-plugin-standard": "^4.0.1"
16 |   },
17 |   "eslintConfig": {
18 |     "extends": [
19 |       "plugin:meteor/recommended",
20 |       "standard",
21 |       "standard-jsx"
22 |     ],
23 |     "parser": "babel-eslint",
24 |     "parserOptions": {
25 |       "sourceType": "module",
26 |       "allowImportExportEverywhere": true
27 |     },
28 |     "plugins": [
29 |       "react-hooks",
30 |       "meteor"
31 |     ],
32 |     "rules": {
33 |       "jsx-quotes": 0,
34 |       "react/jsx-closing-tag-location": 0,
35 |       "react/jsx-wrap-multilines": 0,
36 |       "react-hooks/rules-of-hooks": "error",
37 |       "react-hooks/exhaustive-deps": "warn"
38 |     },
39 |     "settings": {
40 |       "import/resolver": "meteor"
41 |     }
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/server-collection.js:
--------------------------------------------------------------------------------
 1 | /* global Mongo */
 2 | 
 3 | const collectionRegistry = {}
 4 | 
 5 | export const createCollection = (name, schema, indexes = []) => {
 6 |   const Collection = new Mongo.Collection(name)
 7 |   if (schema) Collection.attachSchema(schema)
 8 |   collectionRegistry[name] = Collection
 9 |   if (indexes.length > 0) {
10 |     const indexObj = {}
11 |     for (const index of indexes) {
12 |       indexObj[index] = 'text'
13 |     }
14 |     Collection.rawCollection().createIndex(indexObj)
15 |   }
16 |   return Collection
17 | }
18 | 
19 | export const getCollectionByName = (name) => collectionRegistry[name]
20 | 


--------------------------------------------------------------------------------
/server-connector.js:
--------------------------------------------------------------------------------
 1 | import { EJSON } from 'meteor/ejson'
 2 | import React, { createContext, useContext, useRef } from 'react'
 3 | import { makePagedRun, makeDataMethod, makePruneMethod, makeSingleRun } from './both'
 4 | 
 5 | const ConnectorContext = createContext()
 6 | export const DataCaptureProvider = ({ handle, children }) => {
 7 |   const ref = useRef([])
 8 |   handle.data = ref.current
 9 |   handle.toEJSON = () => (
10 |     EJSON.stringify(ref.current)
11 |   )
12 |   handle.toScriptTag = () => (
13 |     `<script type="text/ejson" id="__NPCollectionCaptureData__">${EJSON.stringify(ref.current)}</script>`
14 |   )
15 |   return <ConnectorContext.Provider value={ref.current}>
16 |     {children}
17 |   </ConnectorContext.Provider>
18 | }
19 | 
20 | export const createConnector = ({ name, collection, validate, query, single = false }) => {
21 |   const run = single
22 |     ? makeSingleRun(collection, query)
23 |     : makePagedRun(collection, query)
24 |   makeDataMethod(name, validate, run)
25 |   makePruneMethod(name, collection, validate, query)
26 |   return (args = {}) => {
27 |     validate(args)
28 |     const captureData = useContext(ConnectorContext)
29 |     const docs = run(args)
30 |     captureData.push({ name: collection._name, docs: single ? [docs] : docs })
31 |     return [docs, false]
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/server.js:
--------------------------------------------------------------------------------
1 | export { createCollection, getCollectionByName } from './server-collection'
2 | export { DataCaptureProvider, createConnector } from './server-connector'
3 | 


--------------------------------------------------------------------------------