vidigami / backbone-sql Goto Github PK

class A extends Backbone.Model
  schema:
    b: -> ['belongsTo', B]
    c: -> ['belongsTo', C]
  sync: require('backbone-sql').sync(A)
  url: 'postgres://test:[email protected]:3306/test/as'

class B extends Backbone.Model
  schema:
    name: 'String'
    as: -> ['hasMany', B]
    c: -> ['belongsTo', C]
  sync: require('backbone-sql').sync(B)
  url: 'postgres://test:[email protected]:3306/test/bs'

class C extends Backbone.Model
  schema:
    memberships: -> ['hasMany', A]
    roles: -> ['hasMany', B]
  sync: require('backbone-sql').sync(C)
  url: 'postgres://test:[email protected]:3306/test/cs'

A.cursor({$page: true, $offset:0, $limit:150, c_id:12}) # works fine
A.cursor({$page: true, $offset:0, $limit:150, c_id:12, 'b.name': 'foo'}) # fails
# Error: column reference "c_id" is ambiguous, sql: select count(*) from "as" left outer join "roles" on "as"."b_id" = "b"."id" where "c_id" = ? and "b"."name" = ?, bindings: 12,foo
A.cursor({$page: true, $offset:0, $limit:150, 'b.c_id':12, 'b.name': 'foo'}) # works; but suboptimal

      if (protocol === 'sqlite3') {
        connection_info = {
          filename: database_url.host || ':memory:'
        };
      } else {
        connection_info = _.extend({
          host: database_url.hostname,

          port: database_url.port,

          database: database_url.database,
          charset: 'utf8'
        }, database_url.parseAuth() || {});
      }

TypeError: Object [object Object] has no method 'type'
    at One.module.exports.One.initialize (code\node_modules\backbone-sql\node_modules\backbone-orm\backbone-orm.js:6392:70)
    at Schema.module.exports.Schema.initialize (code\node_modules\backbone-sql\node_modules\backbone-orm\backbone-orm.js:2268:17)
    at SqlSync.initialize (code\node_modules\backbone-sql\lib\sync.js:84:19)

class Wall extends Backbone.Model
  schema:
    created_at: 'DateTime'
    name: 'String'
    messages: -> ['hasMany', require('./message')]

class Message extends Backbone.Model
  schema:
    created_at: 'DateTime'
    text: 'Text'
    wall: -> ['belongsTo', require('./wall')]
    user: -> ['belongsTo', require('./user')]

[ { walls_created_at: null,
    walls_name: 'test wall',
    walls_id: 1,
    messages_created_at: null,
    messages_text: null,
    messages_wall_id: null,
    messages_user_id: null,
    messages_id: null } ]

[ { created_at: null, name: 'test wall', id: 1, messages: null } ]

[ { created_at: null, name: 'test wall', id: 1, messages: [] } ]

class Foo extends Backbone.Model
  schema:
    bar: -> ['belongsTo', require('./bar')]
  url: 'postgres://root:[email protected]:5432/example/foos'

class Bar extends Backbone.Model
  schema:
    baz: 'Integer'
    buz: 'Integer'
  url: 'postgres://root:[email protected]:5432/example/bars'

Foo.find {'bars.baz': 1, $sort: 'bars.buz'}, (err, foos) -> console.log foos

Foo.find {'bar.baz': 1, $sort: 'bar.buz'}, (err, foos) -> console.log foos

var Backbone = require('backbone');
var SQLSync = require('backbone-sql').sync;

var Room = Backbone.Model.extend({
  urlRoot: "sqlite://data.db/rooms",
  schema: {
    status: 'String',
    members: function() { return [ 'hasMany', User ] }
  }
});
Room.prototype.sync = SQLSync(Room);

var User = Backbone.Model.extend({
  urlRoot: "sqlite://data.db/users",
  schema: {
    rooms: function() { return [ 'hasMany', Room ] }
  }
});
User.prototype.sync = SQLSync(User);

var room = new Room({ status: 'test' });
room.save(function (err, ret) {
  if (err) throw err;
  console.log("save 1 finished with", err, ret);
});

table rooms has no column named user_id, sql: insert into "rooms"
  ("status", "user_id") values (?, ?), bindings: test,

Owner.cursor({'reverses.id': {$in: []}}).include('reverses').toModels (err, owners) ->
    ...