Merge pull request #59 from radify/develop

Next release

integration-test/index.js

@@ -61,8 +61,9 @@ var expected = {
         description: {
           type: 'string'
         },
-        complete: {
-          type: 'boolean'
+        status: {
+          type: 'string',
+          enum: ['new', 'started', 'complete']
         },
         created_at: {
           type: 'string',

integration-test/setup.sql

@@ -6,11 +6,17 @@ CREATE TABLE tasks
   id serial,
   title character varying(255) NOT NULL,
   description character varying(255),
-  complete boolean NOT NULL DEFAULT false,
+  status text,
   created_at timestamp with time zone DEFAULT now(),
   updated_at timestamp with time zone DEFAULT now(),
   owner integer NOT NULL,
-  PRIMARY KEY (id)
+  PRIMARY KEY (id),
+
+  CONSTRAINT status_is_valid CHECK (
+    status = any(
+      array['new', 'started', 'complete']
+    )
+  )
 );
 
 CREATE TABLE users
@@ -39,7 +45,7 @@ FROM tasks
 INNER JOIN users
   ON users.id = tasks.owner
 WHERE
-  tasks.complete = true
+  tasks.status = 'complete'
 GROUP BY
   users.id;
 

package.json

@@ -82,7 +82,7 @@
   "dependencies": {
     "bluebird": "^3.3.4",
     "callsite": "^1.0.0",
-    "ramda": "^0.19.1"
+    "ramda": "^0.22.1"
   },
   "scripts": {
     "semantic-release": "semantic-release pre && npm publish && semantic-release post"

spec/inspectors/schema.ts

@@ -155,6 +155,26 @@ describe('schema', () => {
         }
       });
     });
+
+    it('declares columns that use a CHECK constraint to match an array of values as `enum`', () => {
+      var result = property({
+        name: 'status',
+        nullable: false,
+        default: null,
+        type: 'text',
+        isprimarykey: false,
+        constraints: [
+          "(status = ANY (ARRAY['new'::text, 'started'::text, 'complete'::text]))"
+        ]
+      });
+
+      expect(result).toEqual({
+        status: {
+          type: 'string',
+          enum: ['new', 'started', 'complete']
+        }
+      });
+    });
   });
 
   describe('.required()', () => {

src/inspectors/schema.sql

@@ -6,7 +6,8 @@ SELECT
   columns.is_nullable::boolean AS nullable,
   columns.character_maximum_length AS length,
   attributes.attndims AS dimensions,
-  indexes.indisprimary AS isPrimaryKey
+  indexes.indisprimary AS isPrimaryKey,
+  constraints
 
 FROM information_schema.columns AS columns
 
@@ -19,6 +20,15 @@ LEFT JOIN pg_catalog.pg_index AS indexes
 ON indexes.indrelid = attributes.attrelid
 AND attributes.attnum = ANY(indexes.indkey)
 
+LEFT JOIN (
+  SELECT conrelid, conkey, array_agg(consrc) AS constraints
+  FROM pg_catalog.pg_constraint
+  WHERE contype = 'c'
+  GROUP BY conrelid, conkey
+) AS constraints
+ON conrelid = attributes.attrelid
+AND attributes.attnum = ANY(conkey)
+
 WHERE columns.table_schema = 'public'
 AND columns.table_name = ${name}
 

src/inspectors/schema.ts

@@ -1,6 +1,6 @@
 import Promise     from 'bluebird';
 import {IDatabase} from 'pg-promise';
-import {mergeAll}  from 'ramda';
+import {mergeAll, flatten}  from 'ramda';
 
 import query from '../util/fileQuery';
 
@@ -13,6 +13,7 @@ export interface Column {
   nullable: boolean;
   default:  string | number;
   isprimarykey: boolean;
+  constraints?: string[];
 }
 
 /**
@@ -30,9 +31,17 @@ export interface SchemaDocument {
  * Describes an object's properties according to the JSON Schema standard
  */
 export interface SchemaProperties {
-  [name: string]: {
-    type: string
-  }
+  [name: string]: PropertyAttributes;
+}
+
+/**
+ * Describes an individual properties' attributes according to the JSON Schema
+ * standard
+ */
+export interface PropertyAttributes {
+  type: string;
+  readOnly?: boolean;
+  enum?: any[];
 }
 
 /**
@@ -126,20 +135,72 @@ export function property(column: Column): SchemaProperties {
     'timestamp with time zone':    {type: 'string', format: 'date-time'}
   };
 
-  var col = TYPES[column.type];
+  return {
+    [column.name]: mergeAll<PropertyAttributes>([
+      TYPES[column.type],
+      isReadOnly(column),
+      isEnumConstraint(column)
+    ])
+  };
+}
 
+/**
+ * Determines if a column should be declared read-only by determining if the
+ * column is a primary key that uses a sequence
+ *
+ * @param column The column to inspect
+ * @returns `{readOnly: true}` if the column should be marked read-only
+ */
+export function isReadOnly(column: Column) {
   var isPrimary = column.isprimarykey &&
     column.nullable === false &&
     typeof column.default === 'string' &&
     (column.default as string).startsWith('nextval');
 
   if (isPrimary) {
-    col.readOnly = true;
+    return {readOnly: true};
   }
+}
 
-  return {
-    [column.name]: col
-  };
+/**
+ * Determines if a column should be declared an enumeration by determining if
+ * the column contains a suitable CHECK constraint
+ *
+ * @param column the column to inspect
+ * @returns `{enum: [values]}` if the column contains a suitable CHECK contraint
+ */
+export function isEnumConstraint(column: Column) {
+  if (!column.constraints || !column.constraints.length) {
+    return;
+  }
+
+  const ENUM_CHECK_REGEX = /^\(.* = ANY \(ARRAY\[(.*)\]\)\)/;
+  const ENUM_EXTRACT_VALUE_REGEX = /^'(.*)'::.*/;
+
+  var values = column.constraints
+    .map(constraint => {
+      if (!constraint) {
+        return;
+      }
+
+      var [match, values] = constraint.match(ENUM_CHECK_REGEX);
+      if (!values) {
+        return;
+      }
+
+      return values.split(', ')
+        .map(value => {
+          var [match, value] = value.match(ENUM_EXTRACT_VALUE_REGEX);
+          return value;
+        })
+    })
+    .filter(values => !!values);
+
+  if (!values.length) {
+    return;
+  }
+
+  return {enum: flatten(values)};
 }
 
 /**