DEPRECIATION NOTICE: Use pg-generator
Project is renamed as pg-generator which
- is flexible and easier to customize, (uses nunjucks templates)
- generates more than sequelize, (provides example templates for sequelize, objection, schwifty etc.)
Links of pg-generator:
- Web: http://www.pg-generator.com
- pg-generator's sequelize page: http://www.pg-generator.com/builtin-templates/sequelize
- npm: https://www.npmjs.com/package/pg-generator
- github: https://github.com/ozum/pg-generator
Türkçe: Turkish Documentation is here
Old module and its documentation is preserved here for reference purposes.
This module is for auto generating Sequelize model from PostgreSQL databases. It reverse engineers your database and generates separate model files for each table. Default configuration parameters are carefully selected and they are sane to use. However it is possible to change most of the behaviours via configuration. This document is based on default configuration. Configuration parameters and default values are written as (Config parameter:value) where appropriate.
This will install module and CLI command
$ npm install -g sequelize-pg-generator
Open terminal, go to your app.js root and create your models automatically into 'model' directory.
$ cd path/to/my/node-app.js
$ spgen -d my_database -u my_user -p my_password
Use Sequelize models provided by auto generated files in your application. See examples below.
var orm = require('./model');
orm.setup('my_database', 'my_user', 'my_password', {
host: '127.0.0.1',
logging: false,
native: false
});
var sequelize = orm.sequelize;
var contact = orm.model('public.contact'); // Can be configured without schema.
Some tips to install on windows. This module uses pg. If you like to use pg-native, below are some tips for windows users for a successful install:
- Python 2 should be installed. As of this writing it is not compatible with Python 3.
- You should add Python to the path and set PYTHONPATH via environment variables.
- PostgreSQL pg_config and libpq.dll must be on path. Usually adding bin and lib folders is ok. (For eaxmple: C:\Program Files\PostgreSQL\9.3\bin C:\Program Files\PostgreSQL\9.3\lib)
- Visual Studio Build Tools (C:\Program Files (x86)\MSBuild) should be installed. Installed automatically after VS 2012. If during install npm asks for different version of Visual Studio you can set it from command line during installation:
npm install -g sequelize-pg-generator --msvs_version=2013
spgen [options]
-h, --host [host] IP address or host name of the database server
--port [port] Port of database server to connect
-d, --database [database] Database name
-u, --user [user] Username to connect to database
-p, --password [password] Password to connect to database
-s, --schema [schema] Comma separated names of the database schemas
-o, --output [output] Output folder
-c, --config [config] Path of the configuration file
-t, --templateName Use builtin template folder with given name
--nolog No log output
--resetConfig Reset configuration. (Side-step. Not for production.)
--throwError Instead of logging errors to console, throws error.
- Fully documented. (JSDoc HTML files are under doc directory),
- Tested,
- No Dependencies on Generated Files,
- Multi schema support,
- One to many relation support (hasMany and belongsTo),
- Many to many relation support (hasMany through and belongsToMany),
- Inter-schema relation support. (i.e. public.account table to other_schema.cutomer table),
- Highly configurable,
- Fully customizable,
- CLI support,
- Smart naming of models and relations,
- Very easy to override auto generated files,
- Exclude tables,
- Debug,
- Table Specific Configuration,
- Validates and prevents naming clash.
For many to many relations Sequelize version 2.0 RC3 and older does not support belongsToMany relation. After this version hasMany through relations are deprecated. Behaviour on this subject can be adjusted via configuration. (Config: generate.hasManyThrough:false and generate.belongsToMany:true)
Generated files have no dependencies besides core modules and Sequelize.
Supports multi PostgreSQL schemas. It is possible to have other schemas than public. User can select which schemas to reverse engineer via CLI or config. If more than one schema is included, models may be prefixed with schema names (Config: generate.useSchemaName: true, database.schema: ["public"]) to prevent tables with same name in different schemas try to have same model name.
contact = orm.model('public.contact'); // Returns sequelize model for contact table.
User can configure not to prefix model names with schema
// In config
{...
generate{
useSchemaName: false
}
}
contact = orm.model('contact'); // Returns sequelize model for contact table.
This module automatically detects one to many relations and generates model.hasMany and model.belongsTo sequelize relations.
If two tables are joined via a join table this module detects it automatically and generates many to many sequelize relations. If a table has more than one foreign key, then it is considered many to many relation join table.
hasMany hasMany
TABLE: product --------< line_item >--------- cart
COLUMNS: id cart_id (FK) id
name product_id (FK) customer_id (FK)
color quantity
This module generates belongsToMany relation and hasMany relation with through option. As of this writing master branch of Sequelize deprecated hasMany through relations. According to version of Sequelize you use, it should be adjusted via config of this module.
Detects relations between tables in different schemas. For example relations between public.account table and other_schema.customer table.
This module uses config module. It is also possible to point a custom configuration file via CLI. See configuration parameters below in this document.
This module uses consolidate compatible templates to generate model files. It uses Swig by default. User can use his/her custom templates without altering original one by pointing (Config: template.folder and template.engine:'swig') config values. Looking default templates in template folder of this module is highly recommended.
There should at least be three files in custom template folder: index.ext Default template file. ext is whatever extension is used for your template engine. index.js This file is copied with generated files. It's purpose is use generated files utils.js This file is copied with generated files. Contains helper functions.
If this module is installed as suggested globally with npm -g then spgen command would be available system wide to generate model files.
If auto generated relationship names and aliases are not so smart for you, it is very easy to override aliases. After first use, a file called alias.json is generated in output folder. Every alias name generated is listed in this file. You can override any names/aliases. Future generated files will use overridden names from this file. If you are OK with some names, leave it as null.
sequelize-pg-generator uses table names or schema.table names for model naming. For relations it uses foreign key names and relation names from your database. (You are naming your relations in database meaningfully right?) Both camel case (tableName) or untouched names (table_name) methods can be used via configuration. Naming conventions are based on Sequelize module suggestions and generated explicitly with 'as' parameter.
product_cart_line_items cart_cart_line_items
TABLE: product -------------------------< line_item >--------------------- cart
COLUMNS: id cart_id (FK) id
name product (FK) customer_id (FK)
color quantity
NOTE: Beware line_item.cart_id has id suffix but line_item.product hasn't. This inconsistency is made purposefully for the sake of this example.
Type of object Naming Rule
-------------- -----------
Model tableName or schema.tableName
hasMany Plural of the relation name in database. Table name from beginning can be stripped.
(Config: generate.stripFirstTableFromHasMany:true)
belongsTo Singular of foreign key. If key name ends with _id it will be stripped. Otherwise
'related' is added at the beginning to prevent it gets clash with column name.
(Config: generate.prefixForBelongsTo:'related')
belongsToMany Plural of the join table name + foreign key which refers other table in join table.
hasMany({through:..}) Plural of the join table name + foreign key which refers other table in join table. (DEPRECATED in Sequelize)
For the example structure:
Relation as Details
-------- -- -------
product.hasMany as:'cartLineItems' (Plural) Table name 'product' is stripped from the beginning
of relation name 'product_cart_line_items'
product.belongsToMany as:'cartLineItemCarts' (Plural) _id suffix is stripped from, relation name (table name striiped)
added to foreign key name 'cart_id'
product.hasMany Through as:'cartLineItemCarts' (Plural) _id suffix is stripped from, relation name (table name striiped)
added to foreign key name 'cart_id'
cart.hasMany as:'cartLineItems' (Plural) Table name 'cart' is stripped from the beginning of
relation name 'cart_cart_line_items'
cart.belongsToMany as:'relatedCartLineItemProducts' (Plural) No _id suffix. 'related' and relation name (table name striiped)
are added as prefix.
cart.hasMany Through as:'relatedcartLineItemProducts' (Plural) No _id suffix. 'related' and relation name (table name striiped)
are added as prefix.
lineItem.belongsTo as:'relatedProduct' (Singular) No _id suffix. 'related' is added as prefix.
lineItem.belongsTo as:'cart' (Singular) _id suffix is stripped from foreign key name
'cart_id'.
Of course as all attributes, you can modify generated files in a non-destructive way as explained below.
By default auto generated files are located path/to/model/definition-files directory. Also there is 'definition-files-custom' directory. Users can create files with same names as auto generated files to override its attributes. There is also utils module generated to make modifications easier.
Those modifications are non destructive, because they override generated file in another file by inheriting it and default index.js file uses inherited files if it exists. Please bear in mind, those modifications occur before sequelize instances are generated.
For example for cart table 'definition-files/cart.js' is generated. User can create 'definition-files-custom/cart.js' and override necessary parts like example below. For all attributes you can look inside auto generated files.
"use strict";
var orm = require('../index.js'),
model = require('../definition-files/public_cart.js'),
util = require('../utils.js')(model),
Seq = orm.Sequelize();
module.exports = model;
util.getAttribute('id').validate = {... Some Sequelize Validations}; // Add Sequelize validation.
util.getRelation('relatedProducts').details.as = 'soldItems'; // Don't like default relation name? Change it.
util.renameAttribute('customerId', 'clientId'); // Change name of the attribute.
It is possible to exclude some table from auto generation. (Config generate.skipTable:[]) array is used to define excluded tables. sequelize-pg-generator skips those tables and relations from and to those tables.
When required and executed first time from your app, default index.js file creates a file called debug.js in the model directory. This file can be examined what type of code is used by index.js. It is same code that would be used if there is no index.js file exists. However if this type of static file is used, it is harder to allow modifications in a non-destructive way.
sequelize-pg-generator prevents naming clas by validating all relation names if same name/alias exists on the same table.
Sometimes for some tables it is needed to have different rules then other tables have. In such situations configuration file allows table level overrides. All 'generate' and 'tableOptions' config parameters can be overridden with 'generateOverride' and 'tableOptionsOverride'.
Below is an example for contact table have specific configuration overrides.
"generate": {
"columnDescription": true,
"tableDescription": true,
...
},
"generateOverride": {
"contact": {
"tableDescription": false
}
},
"tableOptions": {
"timestamps": false,
"camelCase": true,
"paranoid": false,
...
},
"tableOptionsOverride": {
"contact": {
"paranoid": true
}
}
...
Configuration parameters and default values are described below. Configuration is enclosed in "sequelize-pg-generator" key, because you may want to combine sequelize-pg-generator configuration with your main application configuration. This way generator's configuration does not clash with yours. node-config allows this.
| host | string | IP address or host name of the database server. |
| port | number | Port of database server to connect. |
| database | string | Database name. |
| user | string | Username to connect to database. |
| password | string | Password to connect to database. |
| schema | Array(string) | Array of names of the database schemas to be parsed. |
| engine | string | Template engine to use for generating model files. Any [consolidate](https://www.npmjs.com/package/consolidate) compatible template engine can be used. |
| extension | string | Extension of template files. |
| folder | string | Path of the template directory which contains template files. |
| log | boolean | Generate log during auto-generation to console. |
| folder | string | Path to output directory for generated model files. |
| beautify | boolean | Format code nicely with [js-beautifier](http://jsbeautifier.org). |
| indent | number | Number of spaces used for each indentation level in generated files. |
| preserveNewLine | boolean | Preserve new lines coming from templates during generation. |
| warning | boolean | If set true, generator includes informative warning text inside generated files. This text is about how to customize and override default models. |
| stripFirstTableFromHasMany | boolean | If this is set true. Generator strips first table name from has many relations' name if it begins with table name. For example "product_cart_line_items" relation becomes "cart_line_items" for "product" table. |
| addTableNameToManyToMany | boolean | If this is set true. Generator adds name of the join table to many to many relationships. This prevents name collision. |
| addRelationNameToManyToMany | boolean | If this is set true. Generator adds name of the relation to many to many relationships. This prevents name collision further than addTableNameToManyToMany, because more than two table can be connected to join table. |
| stripFirstTableNameFromManyToMany | boolean | If this is set true. Generator strips first table name from many to many relations' name if it begins with table name. For example "product_cart_line_items" relation becomes "cart_line_items" for "product" table. |
| hasManyThrough | boolean | Tells generator to generate has many through relations like hasMany(modelName, { through: '..' }. After Sequelize version 2.0 RC3 has many through relations are DEPRECATED. Use belongToMany instead. hasMany through and belongsToMany cannot be true at the same time for the same table. |
| belongsToMany | boolean | Tells generator to generate belongsToMany relations which comes to Sequelize version 2.0 RC4. Prior Sequelize versions do not work if this option set true. hasMany through and belongsToMany cannot be true at the same time for the same table. |
| prefixForBelongsTo | string | belongsTo relations use foreign key name "_id" suffix stripped. If foreign key does not contain "_id" suffix, generator add this prefix to belongsTo relations to prevent column accessor and relation accessor clash. See "Smart Naming of Models and Relations" section above. |
| useSchemaName | boolean | If this is set true, generator adds schema name beginning of generated file names and model names. This is useful for multi schema databases for preventing same table name from clashing. |
| modelCamelCase | boolean | Use camel case (like schemaName) in schema names. |
| relationAccessorCamelCase | boolean | Use camel case (like relationName) in relation accessor names. |
| columnAccessorCamelCase | boolean | Use came case (like columnName) in column accessor names. |
| columnDefault | boolean | Generate default values to the model. WARNING: Does not support SQL functions yet. It is hard to implement this in Sequelize way. IMHO it is best to leave that to DBMS. However you can set it true and override false generated SQL functions. |
| columnDescription | boolean | Include column description in generated model files. |
| columnAutoIncrement | boolean | Include auto increment option of attributes in generated model files. |
| tableDescription | boolean | Include table description in generated model files. |
| dataTypeVariable | string | Sequelize uses object variable to define data types like "Sequelize.BOOLEAN". This configuration parameter sets the name of the variable. |
| skipTable | Array(string) | List of table names not to generate model files for. |
| User can include any Sequelize.define options here. These options are directly passed to Sequelize.define. See Sequelize docs. Some examples: | ||
| timestamps | boolean | Adds createdAt and updatedAt timestamps to the model. |
Default configuration settings are listed below:
module.exports = {
"sequelize-pg-generator": {
"database": {
"host": "127.0.0.1",
"port": 5432,
"user": "user",
"password": "password",
"database": "",
"schema": ["public"]
},
"template": {
"engine": "swig",
"extension": "html",
"folder": path.join(__dirname, '..', 'template')
},
"output": {
"log": true,
"folder": "./model",
"beautify": true,
"indent": 4,
"preserveNewLines": false,
"warning": true
},
"generate": {
"stripFirstTableFromHasMany": true,
"addTableNameToManyToMany": false,
"addRelationNameToManyToMany": true,
"stripFirstTableNameFromManyToMany": true,
"hasManyThrough": false,
"belongsToMany": true,
"prefixForBelongsTo": "related",
"useSchemaName": true,
"modelCamelCase": true,
"relationAccessorCamelCase": true,
"columnAccessorCamelCase": true,
"columnDefault": false,
"columnDescription": true,
"columnAutoIncrement": true,
"tableDescription": true,
"dataTypeVariable": "Seq",
"skipTable": []
},
"tableOptions": {
"timestamps": false
}
}
};
This module uses config module via require('config') for configuration. Config module is a singleton as of this writing, which returns same config object for each request. As a result subsequent calls in the same process return same configuration even configuration file changed and/or sequelize-pg-generator constructor called with different config file.
This is usually no problem since generator supposed to be called once in the same process. However this behaviour prevents testing. Additionally you may want to avoid this behavior whatever reason. To side step this, it is added "resetConfig" option to constructor. If it is set to true it resets and rereads configuration. To do this we clear config module from node cache. It is sub-optimal solution suggested by lorenwest in github issues section.
To activate this behavior just set resetConfig to true or from cli add --resetConfig:
var generator = require('sequelize-pg-generator');
generator(function (err) {
if (err) { callback(err); }
}, {
database: 'my_database',
resetConfig: true
);
sequelize-pg-creator uses the code below:
global.NODE_CONFIG = null;
delete require.cache[require.resolve('config')];
config = require('config');
To create custom templates user can copy default templates or create from scratch then configure "template.folder" to use newly created templates. 3 files are required: index.ext (.ext is whatever your template engine's extension is), index.js, utils.js.
index.js and utils.js files will be copied directly to target model directory. index.ext template is executed for each table to create model files.
Variables available to use in templates are listed below. Please note if a value is undefined, it's key is also is deleted to make it easy to iterate only defined values in templates.
| mainScript | Path to generated index.js file in target model directory. |
| warning | This value comes from configuration which indicates if user wants to include warning message about customizations in generated model files. |
| table | Table object which has table details, columns and relations etc. |
| table.modelName | Model name for table. |
| table.tableName | Name of the table. |
| table.schema | PostgreSQL schema name of the table |
| table.comment | Comment of the table. |
| table.baseFileName | Base part of the file name. |
| SPECIAL | Options from configuration file is also available under table. For example: table.timestamps |
| table.columns | Array which contains columns of the table. |
| table.columns[n].source | 'generator' string. Indicates that this is generated by auto generator. If user needs to access manually modified parts, it is possible to use this field to filter out automatically generated parts. |
| table.columns[n].type | Sequelize type of the column. |
| table.columns[n].accessorName | Accessor name of column. |
| table.columns[n].name | Name of the column |
| table.columns[n].primaryKey | True if this column is a primary key. |
| table.columns[n].autoIncrement | True if this column is a auto increment column. |
| table.columns[n].allowNull | Boolean value to indicate if this column is allowed to have null values. |
| table.columns[n].defaultValue | Dafault value of column. |
| table.columns[n].unique | String value of unique key's name. Sequelize use unique key name to support composite unique keys. It also works for single column unique values. |
| table.columns[n].comment | Description of the column. This comes from database server. |
| table.columns[n].references | If this column has a reference, this value is the name of table which this column references to. |
| table.columns[n].referencesKey | If this column has a reference, this value is the name of foreign key which this column references to. |
| table.columns[n].onUpdate | On update value of the column. (SET NULL, CASCADE, RESTRICT etc.) |
| table.columns[n].onDelete | On delete value of the column. (SET NULL, CASCADE, RESTRICT etc.) |
| table.hasManies | Array which contains hasMany relations of the table. |
| table.hasManies[n].type | 'hasMany' string which indicates relation type. |
| table.hasManies[n].source | 'generator' string. Indicates that this is generated by auto generator. If user needs to access manually modified parts, it is possible to use this field to filter out automatically generated parts. |
| table.hasManies[n].name | Name of the relation in database server. |
| table.hasManies[n].model | Model name which this relation refers to. |
| table.hasManies[n].as | Alias for relation. This alias is used to access this relation from Sequelize. |
| table.hasManies[n].targetSchema | PostgreSQL schema name which this relation refers to. |
| table.hasManies[n].targetTable | Table name which this table refers to. |
| table.hasManies[n].foreignKey | Foreign key column name in the target table. |
| table.hasManies[n].onDelete | onDelete value from database. |
| table.hasManies[n].onUpdate | onUpdate value from database. |
| table.hasManies[n].through | If this is a through relationship (many to many) name of the join table. Through relations are DEPRECATED as of Sequelize 2.0 RC4. |
| table.belongsTos | Array which contains belongsTo relations of the table. |
| table.belongsTos[n].type | 'belongsTo' string which indicates relation type. |
| table.belongsTos[n].source | 'generator' string. Indicates that this is generated by auto generator. If user needs to access manually modified parts, it is possible to use this field to filter out automatically generated parts. |
| table.belongsTos[n].name | Name of the relation in database server. |
| table.belongsTos[n].model | Model name which this relation refers to. |
| table.belongsTos[n].as | Alias for relation. This alias is used to access this relation from Sequelize. |
| table.belongsTos[n].targetSchema | PostgreSQL schema name which this relation refers to. |
| table.belongsTos[n].targetTable | Table name which this table refers to. |
| table.belongsTos[n].foreignKey | Foreign key column name in this table regarding this relation. |
| table.belongsTos[n].onDelete | onDelete value from database. |
| table.belongsTos[n].onUpdate | onUpdate value from database. |
| table.belongsToManies | Array which contains belongsToMany relations of the table. belongsToMany relations are available in Sequelize 2.0 RC4 and newer versions. |
| table.belongsToManies[n].type | 'belongsToMany' string which indicates relation type. |
| table.belongsToManies[n].source | 'generator' string. Indicates that this is generated by auto generator. If user needs to access manually modified parts, it is possible to use this field to filter out automatically generated parts. |
| table.belongsToManies[n].name | Name of the relation in database server. |
| table.belongsToManies[n].model | Model name which this relation refers to. |
| table.belongsToManies[n].as | Alias for relation. This alias is used to access this relation from Sequelize. |
| table.belongsToManies[n].targetSchema | PostgreSQL schema name which this relation refers to. |
| table.belongsToManies[n].targetTable | Table name which this table refers to. |
| table.belongsToManies[n].foreignKey | Foreign key column name in join table referencing to this table. |
| table.belongsToManies[n].otherKey | Foreign key column name in join table referencing to target table. |
| table.belongsToManies[n].onDelete | onDelete value from database. |
| table.belongsToManies[n].onUpdate | onUpdate value from database. |
| table.belongsToManies[n].through | Name of the join table. |
| table.relations | Array which contains all relations combined of the table. This array contains hasMany relations, hasMany through ilişkileri, belongsTo relations, belongsToMany relations. |
sequelize-pg-generator sets up relations with an "as". Otherwise multiple relations between same two tables collides. For example:
account has many contacts as primaryContacts (account -----< contact)
account has many contacts as secondaryContacts (account ----< contact)
In this case sequelize.js requires you to specify "as" alias in the "as" attribute during eager loading.
account = orm.model('public.account'); // Can be configured without schema.
contact = orm.model('public.contact'); // Can be configured without schema.
account.findAll({ include: [ { model: contact, as: "primaryContacts" } ] }).then(function(data) {
console.log(data[0].primaryContacts[0].name);
});
Kind: Exported function
| Param | Type | Description |
|---|---|---|
| callback | function |
Function to execute after completion of auto generation. callback(err) |
| options | object |
Options to override configuration parameters from config file |
| options.host | string |
IP address or host name of the database server |
| options.port | number |
Port of database server to connect |
| options.database | string |
Database name |
| options.user | string |
Username to connect to database |
| options.password | string |
Password to connect to database |
| options.schema | Array |
List of comma separated names of the database schemas to traverse. Example public,extra_schema. |
| options.output | string |
Output folder |
| options.config | string |
Path of the configuration file |
| options.nolog | boolean |
Don't output log of generated files. |
| options.resetConfig | boolean |
Reset configuration via side-step solution to prevent singleton behaviour. (Not recomended for production) |
Kind: global class
| Param |
|---|
| model |
Searches and returns relation with the given alias. Alias is defined in sequelize options with parameter 'as'
Kind: instance method of GeneratorUtil
| Param | Type | Description |
|---|---|---|
| as | string |
Alias of the relation. |
Searches and returns attribute with the given alias. Alias is defined in sequelize options with parameter 'as'
Kind: instance method of GeneratorUtil
| Param | Type | Description |
|---|---|---|
| name | string |
Name of the attribute. |
Searches and returns attribute with the given alias. Alias is defined in sequelize options with parameter 'as'
Kind: instance method of GeneratorUtil
Throws:
- Will throw error if there is already an attribute with new name exists or attribute with oldName does not exists.
| Param | Type | Description |
|---|---|---|
| oldName | string |
Name of the attribute which it's name to be changed. |
| newName | string |
New name of the attribute. |
Version history for minimal documentation updates are not listed here to prevent cluttering.
- Added: sequelize-types are added. (pg-structure deprecated it.)
- Added:
alias.jsonfile is generated in target directory to let developer easily override relationship names.
- Changed: Location of utils.js is changed to inside of model directory.
- -t --templateName parameter added to spgen. This name is used to choose one of the builtin template directories.
- sequalize4 template added for protect backward compatibility.
- sequalize4 template supports object references property. (references and referencesKey will be depreciated in Sequelize 4)
- pg-structure updated to latest version.
- Added: JSONB support and Boolean default value. Contributed by viniciuspinto (https://github.com/viniciuspinto)
- Added documentation and examples.
- Tested for Sequelize 2.0 RC7
- Removed: pg-native dependency removed. Some users experienced problems during install.
- Added: generate.addRelationNameToManyToMany configuration to prefix relation aliases prevent further name clashes which cannot be prevented by generate.addTableNameToManyToMany. Default: true.
- Added: generate.stripFirstTableNameFromManyToMany configuration added. Default: true
- Changed: generate.addTableNameToManyToMany configuration default is false now.
- Changed: Default naming rule for many to many relations.
- Added: Logging uses Winston module now.
- Added: Doc update for Windows OS users.
- Fixed: Database tables without any column throws error when warning configuration is true.
- Added: Automatic alias and naming validations to prevent name clash.
- Added: generate.addTableNameToManyToMany configuration to prefix relation aliases prevent name clash. Default: true.
- Added: --throwError option added to CLI. This option decides wheter to throw error or simply log.
- Added: Prevent hasMany through and belongsToMany true at the same time.
- Fixed: generate.prefixForBelongsTo aliases are not properly camel cased.
- Fixed: --resetConfig option does not work from CLI
- Doc update
- Fixed: CLI command does not work.
- Added: Required parameters warning.
- Added: Turkish documentation added.
- Fixed: Typos and mistakes in documents.
- Added: Tests added.
- Added: --nolog option added to spgen command.
- Added: --resetConfig option. Also details and caveat added to the document.
- Fix: lib/index.js exported function expects different parameters than written in documentation.
- Fix: Command line arguments fixed.
- Fix: Data type variable name configuration is ignored.
- Document update.
- Initial version.
The MIT License (MIT)
Copyright (c) 2014 Özüm Eldoğan
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.