makedb.js

// Generated by psc-bundle 0.8.5.0
var PS = {};
(function(exports) {
  /* global exports */
  "use strict";

  // module Prelude

  //- Functor --------------------------------------------------------------------

  exports.arrayMap = function (f) {
    return function (arr) {
      var l = arr.length;
      var result = new Array(l);
      for (var i = 0; i < l; i++) {
        result[i] = f(arr[i]);
      }
      return result;
    };
  };

  //- Show -----------------------------------------------------------------------

  exports.showIntImpl = function (n) {
    return n.toString();
  };
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Prelude"];
  var Functor = function (map) {
      this.map = map;
  };
  var Apply = function (__superclass_Prelude$dotFunctor_0, apply) {
      this["__superclass_Prelude.Functor_0"] = __superclass_Prelude$dotFunctor_0;
      this.apply = apply;
  };
  var Applicative = function (__superclass_Prelude$dotApply_0, pure) {
      this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
      this.pure = pure;
  };
  var Bind = function (__superclass_Prelude$dotApply_0, bind) {
      this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
      this.bind = bind;
  };
  var Monad = function (__superclass_Prelude$dotApplicative_0, __superclass_Prelude$dotBind_1) {
      this["__superclass_Prelude.Applicative_0"] = __superclass_Prelude$dotApplicative_0;
      this["__superclass_Prelude.Bind_1"] = __superclass_Prelude$dotBind_1;
  };
  var Show = function (show) {
      this.show = show;
  };                                                                           
  var unit = {};                                     
  var showInt = new Show($foreign.showIntImpl);
  var show = function (dict) {
      return dict.show;
  };                  
  var pure = function (dict) {
      return dict.pure;
  };
  var map = function (dict) {
      return dict.map;
  };
  var $less$dollar$greater = function (dictFunctor) {
      return map(dictFunctor);
  };
  var functorArray = new Functor($foreign.arrayMap);
  var $$const = function (a) {
      return function (v) {
          return a;
      };
  };
  var $$void = function (dictFunctor) {
      return function (fa) {
          return $less$dollar$greater(dictFunctor)($$const(unit))(fa);
      };
  };
  var bind = function (dict) {
      return dict.bind;
  };
  var $greater$greater$eq = function (dictBind) {
      return bind(dictBind);
  }; 
  var apply = function (dict) {
      return dict.apply;
  }; 
  var append = function (dict) {
      return dict.append;
  };
  var $less$greater = function (dictSemigroup) {
      return append(dictSemigroup);
  };
  exports["Show"] = Show;
  exports["Monad"] = Monad;
  exports["Bind"] = Bind;
  exports["Applicative"] = Applicative;
  exports["Apply"] = Apply;
  exports["Functor"] = Functor;
  exports["show"] = show;
  exports["<>"] = $less$greater;
  exports["append"] = append;
  exports[">>="] = $greater$greater$eq;
  exports["bind"] = bind;
  exports["pure"] = pure;
  exports["apply"] = apply;
  exports["void"] = $$void;
  exports["<$>"] = $less$dollar$greater;
  exports["map"] = map;
  exports["const"] = $$const;
  exports["unit"] = unit;
  exports["functorArray"] = functorArray;
  exports["showInt"] = showInt;
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.joinWith = function (s) {
    return function (xs) {
      return xs.join(s);
    };
  };
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var mempty = function (dict) {
      return dict.mempty;
  };
  exports["mempty"] = mempty;
})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.String"];
  var Prelude = PS["Prelude"];
  var Data_Char = PS["Data.Char"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_String_Unsafe = PS["Data.String.Unsafe"];
  exports["joinWith"] = $foreign.joinWith;
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
    "use strict";

  // module Database.AnyDB
  /* eslint-env node*/
  /* eslint "no-underscore-dangle": 0 */

  exports.connect_ = function connect_(conString) {
    return function(success, error) {
      var anyDB = require("any-db");
      anyDB.createConnection(conString, function(err, con) {
        if (err) {
          error(err);
        } else {
          success(con);
        }
      });
    };
  };

  exports.runQuery_ = function runQuery_(queryStr) {
    return function(con) {
      return function(success, error) {
        con.query(queryStr, function(err, result) {
          if (err) {
            error(err);
          } else {
            success(result.rows);
          }
        });
      };
    };
  };

  exports.close = function close(con) {
    return function() {
      con.end();
    };
  };
})(PS["Database.AnyDB"] = PS["Database.AnyDB"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.runPure = function (f) {
    return f();
  };
})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff"];
  var Prelude = PS["Prelude"];
  exports["runPure"] = $foreign.runPure;
})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foldable

  exports.foldrArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = len - 1; i >= 0; i--) {
          acc = f(xs[i])(acc);
        }
        return acc;
      };
    };
  };

  exports.foldlArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = 0; i < len; i++) {
          acc = f(acc)(xs[i]);
        }
        return acc;
      };
    };
  };
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Foldable"];
  var Prelude = PS["Prelude"];
  var Control_Apply = PS["Control.Apply"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Maybe_Last = PS["Data.Maybe.Last"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];        
  var Foldable = function (foldMap, foldl, foldr) {
      this.foldMap = foldMap;
      this.foldl = foldl;
      this.foldr = foldr;
  };
  var foldr = function (dict) {
      return dict.foldr;
  };
  var foldl = function (dict) {
      return dict.foldl;
  }; 
  var foldMapDefaultR = function (dictFoldable) {
      return function (dictMonoid) {
          return function (f) {
              return function (xs) {
                  return foldr(dictFoldable)(function (x) {
                      return function (acc) {
                          return Prelude["<>"](dictMonoid["__superclass_Prelude.Semigroup_0"]())(f(x))(acc);
                      };
                  })(Data_Monoid.mempty(dictMonoid))(xs);
              };
          };
      };
  };
  var foldableArray = new Foldable(function (dictMonoid) {
      return foldMapDefaultR(foldableArray)(dictMonoid);
  }, $foreign.foldlArray, $foreign.foldrArray);
  var foldMap = function (dict) {
      return dict.foldMap;
  };
  exports["Foldable"] = Foldable;
  exports["foldMapDefaultR"] = foldMapDefaultR;
  exports["foldMap"] = foldMap;
  exports["foldl"] = foldl;
  exports["foldr"] = foldr;
  exports["foldableArray"] = foldableArray;
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Extend = PS["Control.Extend"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];        
  var Left = (function () {
      function Left(value0) {
          this.value0 = value0;
      };
      Left.create = function (value0) {
          return new Left(value0);
      };
      return Left;
  })();
  var Right = (function () {
      function Right(value0) {
          this.value0 = value0;
      };
      Right.create = function (value0) {
          return new Right(value0);
      };
      return Right;
  })();
  var either = function (v) {
      return function (v1) {
          return function (v2) {
              if (v2 instanceof Left) {
                  return v(v2.value0);
              };
              if (v2 instanceof Right) {
                  return v1(v2.value0);
              };
              throw new Error("Failed pattern match at Data.Either line 29, column 1 - line 30, column 1: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
          };
      };
  };
  exports["Left"] = Left;
  exports["Right"] = Right;
  exports["either"] = either;
})(PS["Data.Either"] = PS["Data.Either"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  //------------------------------------------------------------------------------
  // Array size ------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.length = function (xs) {
    return xs.length;
  };
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Biapplicative = PS["Control.Biapplicative"];
  var Control_Biapply = PS["Control.Biapply"];
  var Control_Comonad = PS["Control.Comonad"];
  var Control_Extend = PS["Control.Extend"];
  var Control_Lazy = PS["Control.Lazy"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];        
  var Tuple = (function () {
      function Tuple(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      Tuple.create = function (value0) {
          return function (value1) {
              return new Tuple(value0, value1);
          };
      };
      return Tuple;
  })();
  exports["Tuple"] = Tuple;
})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Array"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Lazy = PS["Control.Lazy"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  exports["length"] = $foreign.length;
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports._pure = function (nonCanceler, v) {
    return function(success, error) {
      try {
        success(v);
      } catch (err) {
        error(err);
      }

      return nonCanceler;
    };
  }

  exports._throwError = function (nonCanceler, e) {
    return function(success, error) {
      error(e);

      return nonCanceler;
    };
  }

  exports._fmap = function (f, aff) {
    return function(success, error) {
      return aff(function(v) {
        try {
          success(f(v));
        } catch (err) {
          error(err);
        }
      }, error);
    };
  }

  exports._bind = function (alwaysCanceler, aff, f) {
    return function(success, error) {
      var canceler1, canceler2;

      var isCanceled    = false;
      var requestCancel = false;

      var onCanceler = function(){};

      canceler1 = aff(function(v) {
        if (requestCancel) {
          isCanceled = true;

          return alwaysCanceler;
        } else {
          canceler2 = f(v)(success, error);

          onCanceler(canceler2);

          return canceler2;
        }
      }, error);

      return function(e) {
        return function(s, f) {
          requestCancel = true;

          if (canceler2 !== undefined) {
            return canceler2(e)(s, f);
          } else {
            return canceler1(e)(function(bool) {
              if (bool || isCanceled) {
                try {
                  s(true);
                } catch (err) {
                  f(err);
                }
              } else {
                onCanceler = function(canceler) {
                  canceler(e)(s, f);
                };
              }
            }, f);
          }
        };
      };
    };
  }

  exports._attempt = function (Left, Right, aff) {
    return function(success, error) {
      return aff(function(v) {
        try {
          success(Right(v));
        } catch (err) {
          error(err);
        }
      }, function(e) {
        try {
          success(Left(e));
        } catch (err) {
          error(err);
        }
      });
    };
  }

  exports._runAff = function (errorT, successT, aff) {
    return function() {
      return aff(function(v) {
        try {
          successT(v)();
        } catch (err) {
          errorT(err)();
        }
      }, function(e) {
        errorT(e)();
      });
    };
  }

  exports._liftEff = function (nonCanceler, e) {
    return function(success, error) {
      try {
        success(e());
      } catch (err) {
        error(err);
      }

      return nonCanceler;
    };
  }
})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
  var MonadEff = function (__superclass_Prelude$dotMonad_0, liftEff) {
      this["__superclass_Prelude.Monad_0"] = __superclass_Prelude$dotMonad_0;
      this.liftEff = liftEff;
  };                                 
  var liftEff = function (dict) {
      return dict.liftEff;
  };
  exports["MonadEff"] = MonadEff;
  exports["liftEff"] = liftEff;
})(PS["Control.Monad.Eff.Class"] = PS["Control.Monad.Eff.Class"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Control.Monad.Eff.Exception

  exports.showErrorImpl = function (err) {
    return err.stack || err.toString();
  };
})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff.Exception"];
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];                                 
  var showError = new Prelude.Show($foreign.showErrorImpl);
  exports["showError"] = showError;
})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];        
  var MonadError = function (__superclass_Prelude$dotMonad_0, catchError, throwError) {
      this["__superclass_Prelude.Monad_0"] = __superclass_Prelude$dotMonad_0;
      this.catchError = catchError;
      this.throwError = throwError;
  };
  var throwError = function (dict) {
      return dict.throwError;
  };                          
  var catchError = function (dict) {
      return dict.catchError;
  };
  exports["MonadError"] = MonadError;
  exports["catchError"] = catchError;
  exports["throwError"] = throwError;
})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Aff"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Either = PS["Data.Either"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function = PS["Data.Function"];
  var Data_Monoid = PS["Data.Monoid"];
  var runAff = function (ex) {
      return function (f) {
          return function (aff) {
              return $foreign._runAff(ex, f, aff);
          };
      };
  };
  var functorAff = new Prelude.Functor(function (f) {
      return function (fa) {
          return $foreign._fmap(f, fa);
      };
  });
  var attempt = function (aff) {
      return $foreign._attempt(Data_Either.Left.create, Data_Either.Right.create, aff);
  };
  var applyAff = new Prelude.Apply(function () {
      return functorAff;
  }, function (ff) {
      return function (fa) {
          return $foreign._bind(alwaysCanceler, ff, function (f) {
              return Prelude["<$>"](functorAff)(f)(fa);
          });
      };
  });
  var applicativeAff = new Prelude.Applicative(function () {
      return applyAff;
  }, function (v) {
      return $foreign._pure(nonCanceler, v);
  });
  var nonCanceler = Prelude["const"](Prelude.pure(applicativeAff)(false));
  var alwaysCanceler = Prelude["const"](Prelude.pure(applicativeAff)(true));
  var bindAff = new Prelude.Bind(function () {
      return applyAff;
  }, function (fa) {
      return function (f) {
          return $foreign._bind(alwaysCanceler, fa, f);
      };
  });
  var monadAff = new Prelude.Monad(function () {
      return applicativeAff;
  }, function () {
      return bindAff;
  });
  var monadEffAff = new Control_Monad_Eff_Class.MonadEff(function () {
      return monadAff;
  }, function (eff) {
      return $foreign._liftEff(nonCanceler, eff);
  });
  var monadErrorAff = new Control_Monad_Error_Class.MonadError(function () {
      return monadAff;
  }, function (aff) {
      return function (ex) {
          return Prelude[">>="](bindAff)(attempt(aff))(Data_Either.either(ex)(Prelude.pure(applicativeAff)));
      };
  }, function (e) {
      return $foreign._throwError(nonCanceler, e);
  });
  var $$finally = function (aff1) {
      return function (aff2) {
          return Prelude.bind(bindAff)(attempt(aff1))(function (v) {
              return Prelude.bind(bindAff)(aff2)(function () {
                  return Data_Either.either(Control_Monad_Error_Class.throwError(monadErrorAff))(Prelude.pure(applicativeAff))(v);
              });
          });
      };
  };
  exports["runAff"] = runAff;
  exports["nonCanceler"] = nonCanceler;
  exports["finally"] = $$finally;
  exports["attempt"] = attempt;
  exports["functorAff"] = functorAff;
  exports["applyAff"] = applyAff;
  exports["applicativeAff"] = applicativeAff;
  exports["bindAff"] = bindAff;
  exports["monadAff"] = monadAff;
  exports["monadEffAff"] = monadEffAff;
  exports["monadErrorAff"] = monadErrorAff;
})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Database.AnyDB"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Trans = PS["Control.Monad.Trans"];
  var Data_Either = PS["Data.Either"];
  var Data_Array = PS["Data.Array"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Maybe = PS["Data.Maybe"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Data_Traversable = PS["Data.Traversable"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];        
  var Query = function (x) {
      return x;
  };
  var Postgres = (function () {
      function Postgres(value0) {
          this.value0 = value0;
      };
      Postgres.create = function (value0) {
          return new Postgres(value0);
      };
      return Postgres;
  })();
  var Sqlite3 = (function () {
      function Sqlite3(value0) {
          this.value0 = value0;
      };
      Sqlite3.create = function (value0) {
          return new Sqlite3(value0);
      };
      return Sqlite3;
  })();
  var mkConnectionString = function (v) {
      if (v instanceof Postgres) {
          return "postgres://" + (v.value0.user + (":" + (v.value0.password + ("@" + (v.value0.host + (":" + (Prelude.show(Prelude.showInt)(v.value0.port) + ("/" + v.value0.db))))))));
      };
      if (v instanceof Sqlite3) {
          return "sqlite3://" + (function () {
              if (v.value0.memory) {
                  return ":memory:";
              };
              if (!v.value0.memory) {
                  return v.value0.filename;
              };
              throw new Error("Failed pattern match at Database.AnyDB line 71, column 36 - line 74, column 1: " + [ v.value0.memory.constructor.name ]);
          })();
      };
      throw new Error("Failed pattern match at Database.AnyDB line 65, column 1 - line 71, column 1: " + [ v.constructor.name ]);
  };
  var execute_ = function (v) {
      return function (con) {
          return Prelude["void"](Control_Monad_Aff.functorAff)($foreign.runQuery_(v)(con));
      };
  }; 
  var connect = function ($62) {
      return $foreign.connect_(mkConnectionString($62));
  };
  var withConnection = function (info) {
      return function (p) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(connect(info))(function (v) {
              return Control_Monad_Aff["finally"](p(v))(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)($foreign.close(v)));
          });
      };
  };
  exports["Postgres"] = Postgres;
  exports["Sqlite3"] = Sqlite3;
  exports["Query"] = Query;
  exports["withConnection"] = withConnection;
  exports["execute_"] = execute_;
  exports["connect"] = connect;
  exports["mkConnectionString"] = mkConnectionString;
})(PS["Database.AnyDB"] = PS["Database.AnyDB"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports._copyEff = function (m) {
    return function () {
      var r = {};
      for (var k in m) {
        if (m.hasOwnProperty(k)) {
          r[k] = m[k];
        }
      }
      return r;
    };
  };

  exports.empty = {};

  exports.runST = function (f) {
    return f;
  };

  function _collect (f) {
    return function (m) {
      var r = [];
      for (var k in m) {
        if (m.hasOwnProperty(k)) {
          r.push(f(k)(m[k]));
        }
      }
      return r;
    };
  }
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.poke = function (m) {
    return function (k) {
      return function (v) {
        return function () {
          m[k] = v;
          return m;
        };
      };
    };
  };
})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.StrMap.ST"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_Maybe = PS["Data.Maybe"];
  exports["poke"] = $foreign.poke;
})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.StrMap"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_List = PS["Data.List"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_StrMap_ST = PS["Data.StrMap.ST"];
  var thawST = $foreign._copyEff;
  var pureST = function (f) {
      return Control_Monad_Eff.runPure($foreign.runST(f));
  };
  var mutate = function (f) {
      return function (m) {
          return pureST(function __do() {
              var v = thawST(m)();
              f(v)();
              return v;
          });
      };
  }; 
  var insert = function (k) {
      return function (v) {
          return mutate(function (s) {
              return Data_StrMap_ST.poke(s)(k)(v);
          });
      };
  };
  exports["thawST"] = thawST;
  exports["insert"] = insert;
  exports["empty"] = $foreign.empty;
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
    "use strict";

  //module App.Model.StrMap

  exports._collect = function _collect (f) {
    return function (m) {
      var r = [];
      for (var k in m) {
        if (m.hasOwnProperty(k)) {
          r.push(f(k)(m[k]));
        }
      }
      return r;
    };
  };
})(PS["App.Model.StrMap"] = PS["App.Model.StrMap"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["App.Model.StrMap"];
  var Prelude = PS["Prelude"];
  var Data_StrMap = PS["Data.StrMap"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Array = PS["Data.Array"];        
  var toArray = $foreign._collect(Data_Tuple.Tuple.create);
  var fromArray = Data_Foldable.foldl(Data_Foldable.foldableArray)(function (acc) {
      return function (v) {
          return Data_StrMap.insert(v.value0)(v.value1)(acc);
      };
  })(Data_StrMap.empty);
  exports["fromArray"] = fromArray;
  exports["toArray"] = toArray;
})(PS["App.Model.StrMap"] = PS["App.Model.StrMap"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_String = PS["Data.String"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Data_Array = PS["Data.Array"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_StrMap = PS["Data.StrMap"];
  var App_Model_StrMap = PS["App.Model.StrMap"];        
  var Char = (function () {
      function Char() {

      };
      Char.value = new Char();
      return Char;
  })();
  var Integer = (function () {
      function Integer() {

      };
      Integer.value = new Integer();
      return Integer;
  })();
  var $$Date = (function () {
      function Date() {

      };
      Date.value = new Date();
      return Date;
  })();
  var Blob = (function () {
      function Blob() {

      };
      Blob.value = new Blob();
      return Blob;
  })();
  var PrimaryKey = (function () {
      function PrimaryKey() {

      };
      PrimaryKey.value = new PrimaryKey();
      return PrimaryKey;
  })();
  var Unique = (function () {
      function Unique() {

      };
      Unique.value = new Unique();
      return Unique;
  })();
  var ColumnDef = (function () {
      function ColumnDef(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ColumnDef.create = function (value0) {
          return function (value1) {
              return new ColumnDef(value0, value1);
          };
      };
      return ColumnDef;
  })();
  var updatedonTrigger = function (upd_ins) {
      return function (n) {
          return function (on) {
              return Data_String.joinWith(" ")([ "CREATE TRIGGER updatedon_" + (upd_ins + ("_" + n)), "AFTER", upd_ins, "ON " + n, "BEGIN", "UPDATE", n, "SET updatedon = datetime('now')", "WHERE", Data_String.joinWith(" AND ")(Prelude.map(Prelude.functorArray)(function (col) {
                  return col + (" = new." + col);
              })(on)), "; END; " ]);
          };
      };
  };
  var updatedonUpdateTrigger = function (v) {
      return function (on) {
          return Database_AnyDB.Query(updatedonTrigger("UPDATE")(v.name)(on));
      };
  };
  var updatedonInsertTrigger = function (v) {
      return function (on) {
          return Database_AnyDB.Query(updatedonTrigger("INSERT")(v.name)(on));
      };
  };
  var showFieldType = new Prelude.Show(function (v) {
      if (v instanceof Char) {
          return "CHAR";
      };
      if (v instanceof Integer) {
          return "INTEGER";
      };
      if (v instanceof $$Date) {
          return "CHAR";
      };
      if (v instanceof Blob) {
          return "BLOB";
      };
      throw new Error("Failed pattern match at SQL line 35, column 3 - line 36, column 3: " + [ v.constructor.name ]);
  });
  var showColumnConstraint = new Prelude.Show(function (v) {
      if (v instanceof PrimaryKey) {
          return "PRIMARY KEY";
      };
      if (v instanceof Unique) {
          return "UNIQUE";
      };
      throw new Error("Failed pattern match at SQL line 41, column 3 - line 42, column 3: " + [ v.constructor.name ]);
  });
  var showColumnDef = new Prelude.Show(function (v) {
      return Prelude.show(showFieldType)(v.value0) + ((function () {
          var $36 = Data_Array.length(v.value1) > 0;
          if ($36) {
              return " ";
          };
          if (!$36) {
              return "";
          };
          throw new Error("Failed pattern match at SQL line 31, column 41 - line 31, column 75: " + [ $36.constructor.name ]);
      })() + Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(Prelude.show(showColumnConstraint))(v.value1)));
  });
  var parens = function (s) {
      return " (" + (s + ")");
  };
  var createColumnDefs = function (s) {
      return Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(function (v) {
          return v.value0 + (" " + Prelude.show(showColumnDef)(v.value1));
      })(App_Model_StrMap.toArray(s)));
  };
  var createTable = function (v) {
      return Database_AnyDB.Query("CREATE TABLE " + (v.name + parens(createColumnDefs(v.columns))));
  };
  exports["Char"] = Char;
  exports["Integer"] = Integer;
  exports["Date"] = $$Date;
  exports["Blob"] = Blob;
  exports["PrimaryKey"] = PrimaryKey;
  exports["Unique"] = Unique;
  exports["ColumnDef"] = ColumnDef;
  exports["updatedonTrigger"] = updatedonTrigger;
  exports["updatedonUpdateTrigger"] = updatedonUpdateTrigger;
  exports["updatedonInsertTrigger"] = updatedonInsertTrigger;
  exports["parens"] = parens;
  exports["createTable"] = createTable;
  exports["createColumnDefs"] = createColumnDefs;
  exports["showColumnDef"] = showColumnDef;
  exports["showFieldType"] = showFieldType;
  exports["showColumnConstraint"] = showColumnConstraint;
})(PS["SQL"] = PS["SQL"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Tuple = PS["Data.Tuple"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var savedFileTable = {
      name: "FILES", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("name")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("eventid")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("file")(new SQL.ColumnDef(SQL.Blob.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  exports["savedFileTable"] = savedFileTable;
})(PS["App.Model.SavedFile"] = PS["App.Model.SavedFile"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Date = PS["Data.Date"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Array = PS["Data.Array"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];                         
  var eventsTable = {
      name: "EVENTS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("name")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("datefrom")(new SQL.ColumnDef((SQL["Date"]).value, [  ])), Data_Tuple.Tuple.create("dateuntil")(new SQL.ColumnDef((SQL["Date"]).value, [  ])), Data_Tuple.Tuple.create("profile")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  exports["eventsTable"] = eventsTable;
})(PS["App.Model.Event"] = PS["App.Model.Event"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Date = PS["Data.Date"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var SQL = PS["SQL"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var insertDefaultNetworkingSate = "INSERT INTO NETWORKINGSTATE (lastsentstatistics) VALUES (date('now'))";
  var createNetworkingStateTable = "CREATE TABLE NETWORKINGSTATE (lastsentstatistics CHAR);";
  exports["insertDefaultNetworkingSate"] = insertDefaultNetworkingSate;
  exports["createNetworkingStateTable"] = createNetworkingStateTable;
})(PS["App.Model.NetworkingState"] = PS["App.Model.NetworkingState"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Array = PS["Data.Array"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];
  var photoboothsTable = {
      name: "PHOTOBOOTHS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Char.value, [ SQL.Unique.value ])), Data_Tuple.Tuple.create("alias")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("defaultprofile")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  exports["photoboothsTable"] = photoboothsTable;
})(PS["App.Model.Photobooth"] = PS["App.Model.Photobooth"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Date = PS["Data.Date"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var sessionsTable = {
      name: "SESSIONS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("userId")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("createdOn")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  exports["sessionsTable"] = sessionsTable;
})(PS["App.Model.Session"] = PS["App.Model.Session"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Date = PS["Data.Date"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];
  var monthlyStatisticsTable = {
      name: "MONTHLYSTATISTICS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("month")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("pictures")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("prints")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };                                                                                 
  var eventStatisticsTable = {
      name: "EVENTSTATISTICS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("eventid")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("pictures")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("prints")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };                                                                           
  var createMonthlyStatisticsTable = "CREATE TABLE MONTHLYSTATISTICS (computername CHAR, month INTEGER, pictures INTEGER, prints INTEGER, updatedon CHAR, PRIMARY KEY (computername, month))";
  var createEventStatisticsTable = "CREATE TABLE EVENTSTATISTICS (computername CHAR, eventid INTEGER, pictures INTEGER, prints INTEGER, updatedon CHAR, PRIMARY KEY (computername, eventid))";
  exports["createMonthlyStatisticsTable"] = createMonthlyStatisticsTable;
  exports["monthlyStatisticsTable"] = monthlyStatisticsTable;
  exports["createEventStatisticsTable"] = createEventStatisticsTable;
  exports["eventStatisticsTable"] = eventStatisticsTable;
})(PS["App.Model.Statistic"] = PS["App.Model.Statistic"] || {});
(function(exports) {
    "use strict";
  var SQL = PS["SQL"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Tuple = PS["Data.Tuple"];
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var usersTable = {
      name: "USERS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("name")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("password")(new SQL.ColumnDef(SQL.Char.value, [  ])) ])
  };
  exports["usersTable"] = usersTable;
})(PS["App.Model.User"] = PS["App.Model.User"] || {});
(function(exports) {
    "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Tuple = PS["Data.Tuple"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];             
  var createWorkerStateTable = "CREATE TABLE WORKERSTATE (activeeventid INTEGER);";
  exports["createWorkerStateTable"] = createWorkerStateTable;
})(PS["App.Model.WorkerState"] = PS["App.Model.WorkerState"] || {});
(function(exports) {
    "use strict";
  var App_Model_Date = PS["App.Model.Date"];
  var App_Model_Event = PS["App.Model.Event"];
  var App_Model_NetworkingState = PS["App.Model.NetworkingState"];
  var App_Model_Photobooth = PS["App.Model.Photobooth"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var App_Model_Session = PS["App.Model.Session"];
  var App_Model_Statistic = PS["App.Model.Statistic"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var App_Model_User = PS["App.Model.User"];
  var App_Model_WorkerState = PS["App.Model.WorkerState"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Data_Array = PS["Data.Array"];
  var Data_Date = PS["Data.Date"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_String = PS["Data.String"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];
  var Node_Buffer = PS["Node.Buffer"];
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var networkingConnectionInfo = new Database_AnyDB.Sqlite3({
      filename: "networkingdb", 
      memory: false
  });
  var makeDB = function (conn) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.createTable(App_Model_Photobooth.photoboothsTable))(conn))(function () {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonInsertTrigger(App_Model_Photobooth.photoboothsTable)([ "id" ]))(conn))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonUpdateTrigger(App_Model_Photobooth.photoboothsTable)([ "id" ]))(conn))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.createTable(App_Model_Event.eventsTable))(conn))(function () {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonInsertTrigger(App_Model_Event.eventsTable)([ "id" ]))(conn))(function () {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonUpdateTrigger(App_Model_Event.eventsTable)([ "id" ]))(conn))(function () {
                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.createTable(App_Model_SavedFile.savedFileTable))(conn))(function () {
                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonInsertTrigger(App_Model_SavedFile.savedFileTable)([ "id" ]))(conn))(function () {
                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonUpdateTrigger(App_Model_SavedFile.savedFileTable)([ "id" ]))(conn))(function () {
                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(App_Model_Statistic.createEventStatisticsTable)(conn))(function () {
                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonInsertTrigger(App_Model_Statistic.eventStatisticsTable)([ "computername", "eventid" ]))(conn))(function () {
                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonUpdateTrigger(App_Model_Statistic.eventStatisticsTable)([ "computername", "eventid" ]))(conn))(function () {
                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(App_Model_Statistic.createMonthlyStatisticsTable)(conn))(function () {
                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonInsertTrigger(App_Model_Statistic.monthlyStatisticsTable)([ "computername", "month" ]))(conn))(function () {
                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.updatedonUpdateTrigger(App_Model_Statistic.monthlyStatisticsTable)([ "computername", "month" ]))(conn))(function () {
                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(App_Model_NetworkingState.createNetworkingStateTable)(conn))(function () {
                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(App_Model_NetworkingState.insertDefaultNetworkingSate)(conn))(function () {
                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(App_Model_WorkerState.createWorkerStateTable)(conn))(function () {
                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(SQL.createTable(App_Model_User.usersTable))(conn))(function () {
                                                                                  return Database_AnyDB.execute_(SQL.createTable(App_Model_Session.sessionsTable))(conn);
                                                                              });
                                                                          });
                                                                      });
                                                                  });
                                                              });
                                                          });
                                                      });
                                                  });
                                              });
                                          });
                                      });
                                  });
                              });
                          });
                      });
                  });
              });
          });
      });
  };
  exports["makeDB"] = makeDB;
  exports["networkingConnectionInfo"] = networkingConnectionInfo;
})(PS["App.DB"] = PS["App.DB"] || {});
(function(exports) {
  /* global exports, console */
  "use strict";

  // module Control.Monad.Eff.Console

  exports.log = function (s) {
    return function () {
      console.log(s);
      return {};
    };
  };
})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff.Console"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  exports["log"] = $foreign.log;
})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
(function(exports) {
    "use strict";
  var App_DB = PS["App.DB"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];        
  var main = Control_Monad_Aff.runAff(function ($2) {
      return Control_Monad_Eff_Console.log(Prelude.show(Control_Monad_Eff_Exception.showError)($2));
  })(function (v) {
      return Control_Monad_Eff_Console.log("DB made");
  })(Database_AnyDB.withConnection(App_DB.networkingConnectionInfo)(App_DB.makeDB));
  exports["main"] = main;
})(PS["App.MakeDB"] = PS["App.MakeDB"] || {});
PS["App.MakeDB"].main();