Untitled

#Sneak peek on what I am planning to create

Base = require './base'
Env = require '/.env'
{extend, capFirst, forEach} = require '/.util'

class Model extends Base

        @setenv: (env) ->
                if Env.isAncestorOf env
                        @_env = env


        @schema: (schema) ->
                if schema?
                        @index(['_date_updated'])
                        @_schema = extend {_date_created:Date, _date_updated:Date}, @_schema
                        @_schema = extend @_schema, schema

                @_schema or= {_date_created:Date, _date_updated:Date}

        @validator: (validator) ->
                if validator?
                        @_validator = extend {}, @_validator
                        @_validator = extend @_validator, validator

                @_validator or= {}

        @constraints: (constrains) ->
                if constraints?
                        @_constraints = extend {}, @_constraints
                        @_constraints = extend @_constraints, constraints

                @_constraints or= {}

        @index: (idx) ->
                if idx?
                        @_index = extend {}, @_index
                        @_index[i] = 1 for i in idx

                @_index or= {}

        @queries: (queries) ->
                if typeof queries is 'string'
                        return @_queries[queries]

                @_queries = extend @_queries or {}, queries
                forEach (name for name of queries), (name) =>
                        @["query#{capFirst name}"] = (obj, opt, callback) ->
                                @query name, obj, opt, callback

                return @_queries

        @access: ->

        @migration: (fn) ->
                if fn
                        @_migration = fn
                return @_migration

        @parseQuery: (query) ->
                query or= {}
                JSON.encode JSON.stringify query

        @collect: (callback) ->
                @_env.db?.collection @_modelName, (error, collection) =>
                        if error
                                throw new Error "Can't retrieve collection '#{@_modelName}'"

                        collection.ensureIndex @_index, ->
                                callback collection

        @find: (args...) ->
                if args.length >= 3
                        [query, options, callback] = args
                else if args.length is 2
                        [query, callback] = args
                else if args.length is 1
                        [callback] = args
                else
                        return

                query = @parseQuery query
                options or= {}
                Self = @

                @collect (collection) ->
                        collection.find query, options, (err, cursor) ->
                                if err
                                        throw new Error "Can't retrieve documents in '#{Self._modelName}'"
                                cursor.toArray (err, docs) ->
                                        records = new Self(docs[i]) for i in docs
                                        callback.call Self, records

        @findOne: (args...) ->
                if args.length >= 2
                        [query, callback] = args
                else if args.length is 1
                        [callback] = args
                else
                        return

                query = @parseQuery query
                Self = @

                @collect (collection) ->
                        collection.findOne (err, doc) ->
                                if err
                                        throw new Error "Can't retrieve document in '#{Self._modelName}'"
                                callback.call Self, new Self(doc)

        @query: (queryName, obj, opt, callback) ->
                query = extend opt.filter or {}, @_queries[queryName].call(this, obj)
                @find @query, opt, callback

        constructor: ->

        validate: ->

        save: (callback)->

        destroy: (callback)->


module.exports = Model