pure-orm 4.0.0-5 → 4.0.0-8

package/src/orm.ts

@@ -0,0 +1,291 @@
+import { createCore, IModel, ICollection, IEntities } from './core';
+import { ICoreIntegratedDriver } from './driver-integrations/index';
+import { createForPGP } from './driver-integrations/pgp';
+
+export interface ICreateOptions {
+  entities: IEntities<IModel>;
+  db: any;
+  logError?: (err: Error) => never;
+}
+
+export interface IPureORM extends ICoreIntegratedDriver {
+  /* ------------------------------------------------------------------------*/
+  /* Built-in basic CRUD functions ------------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  /* These are just provided because they are so common and straight-forward.
+   * While the goal of this library is foster writing SQL in your data access
+   * layer (which returns pure business objects) some CRUD operations are so
+   * common they are included in the ORM. Feel free to completely disregard
+   * if you want to write these in your data access layer yourself.
+   */
+
+  getMatching: <T extends IModel>(model: T) => T;
+  getOneOrNoneMatching: <T extends IModel>(model: T) => T | void;
+  getAnyMatching: <T extends ICollection<IModel>>(model: IModel) => T | void;
+  getAllMatching: <T extends ICollection<IModel>>(model: IModel) => T;
+  create: <T extends IModel>(model: T) => T;
+  update: <T extends IModel>(model: T, options: { on: string }) => T;
+  delete: <T extends IModel>(model: T) => void;
+  deleteMatching: <T extends IModel>(model: T) => void;
+}
+
+export const create = ({
+  entities: externalEntities,
+  db,
+  logError
+}: ICreateOptions): IPureORM => {
+  const core = createCore({ entities: externalEntities });
+
+  let orm: ICoreIntegratedDriver;
+  if (db.$config.pgp) {
+    orm = createForPGP({ core, db, logError });
+  } else {
+    throw new Error(
+      `You're database driver is not yet supported. You can make a PR to add it, or use the \`createCore\` export which doesn't try to abstract over the database driver, and instead you pass the results of the database driver queries to it.`
+    );
+  }
+
+  /* ------------------------------------------------------------------------*/
+  /* Helper Utilities for CRUD functions ------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  const getSqlInsertParts = (model: IModel) => {
+    const columns = orm
+      .getEntityByModel(model)
+      .columnNames.filter(
+        (column: string, index: number) =>
+          model[
+            orm.getEntityByModel(model).propertyNames[
+              index
+            ] as keyof typeof model
+          ] !== void 0
+      )
+      .map((col: string) => `"${col}"`)
+      .join(', ');
+    const values = orm
+      .getEntityByModel(model)
+      .propertyNames.map(
+        (property: string) => model[property as keyof typeof model]
+      )
+      .filter((value: any) => value !== void 0);
+    const valuesVar = values.map(
+      (value: any, index: number) => `$${index + 1}`
+    );
+    return { columns, values, valuesVar };
+  };
+
+  const getSqlUpdateParts = (model: IModel, on = 'id') => {
+    const clauseArray = orm
+      .getEntityByModel(model)
+      .columnNames.filter(
+        (sqlColumn: string, index: number) =>
+          model[
+            orm.getEntityByModel(model).propertyNames[
+              index
+            ] as keyof typeof model
+          ] !== void 0
+      )
+      .map(
+        (sqlColumn: string, index: number) => `"${sqlColumn}" = $${index + 1}`
+      );
+    const clause = clauseArray.join(', ');
+    const idVar = `$${clauseArray.length + 1}`;
+    const _values = orm
+      .getEntityByModel(model)
+      .propertyNames.map(
+        (property: string) => model[property as keyof typeof model]
+      )
+      .filter((value: any) => value !== void 0);
+    const values = [..._values, model[on as keyof typeof model]];
+    return { clause, idVar, values };
+  };
+
+  const getMatchingParts = (model: IModel) => {
+    const whereClause = orm
+      .getEntityByModel(model)
+      .propertyNames.map((property: string, index: number) =>
+        model[property as keyof typeof model] != null
+          ? `"${orm.getEntityByModel(model).tableName}"."${
+              orm.getEntityByModel(model).columnNames[index]
+            }"`
+          : null
+      )
+      .filter((x: string | null) => x != null)
+      .map((x: string | null, i: number) => `${x} = $${i + 1}`)
+      .join(' AND ');
+    const values = orm
+      .getEntityByModel(model)
+      .propertyNames.map((property: string) =>
+        model[property as keyof typeof model] != null
+          ? model[property as keyof typeof model]
+          : null
+      )
+      .filter((x: any) => x != null);
+    return { whereClause, values };
+  };
+
+  // This one returns an object, which allows it to be more versatile.
+  // To-do: make this one even better and use it instead of the one above.
+  const getMatchingPartsObject = (model: IModel) => {
+    const whereClause = orm
+      .getEntityByModel(model)
+      .propertyNames.map((property: string, index: number) =>
+        model[property as keyof typeof model] != null
+          ? `"${orm.getEntityByModel(model).tableName}"."${
+              orm.getEntityByModel(model).columnNames[index]
+            }"`
+          : null
+      )
+      .filter((x: string | null) => x != null)
+      .map((x: string | null, i: number) => `${x} = $(${i + 1})`)
+      .join(' AND ');
+    const values = orm
+      .getEntityByModel(model)
+      .propertyNames.map((property: string) =>
+        model[property as keyof typeof model] != null
+          ? model[property as keyof typeof model]
+          : null
+      )
+      .filter((x: any) => x != null)
+      .reduce(
+        (accum: any, val: any, index: number) =>
+          Object.assign({}, accum, { [index + 1]: val }),
+        {}
+      );
+    return { whereClause, values };
+  };
+
+  const getNewWith = (model: IModel, sqlColumns: any, values: any) => {
+    const Constructor = model.constructor as any;
+    const modelKeys = sqlColumns.map(
+      (key: string) =>
+        orm.getEntityByModel(model).propertyNames[
+          orm.getEntityByModel(model).columnNames.indexOf(key)
+        ]
+    );
+    const modelData = modelKeys.reduce(
+      (data: any, key: string, index: number) => {
+        data[key] = values[index];
+        return data;
+      },
+      {}
+    );
+    return new Constructor(modelData);
+  };
+
+  const getValueBySqlColumn = (model: IModel, sqlColumn: string) => {
+    return model[
+      orm.getEntityByModel(model).propertyNames[
+        orm.getEntityByModel(model).columnNames.indexOf(sqlColumn)
+      ] as keyof typeof model
+    ];
+  };
+
+  /* ------------------------------------------------------------------------*/
+  /* Built-in basic CRUD functions ------------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  // Standard create
+  const create = <T extends IModel>(model: T): T => {
+    const { columns, values, valuesVar } = getSqlInsertParts(model);
+    const query = `
+      INSERT INTO "${orm.getEntityByModel(model).tableName}" ( ${columns} )
+      VALUES ( ${valuesVar} )
+      RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
+    `;
+    return orm.one<T>(query, values);
+  };
+
+  // Standard update
+  const update = <T extends IModel>(model: T, { on = 'id' } = {}): T => {
+    const { clause, idVar, values } = getSqlUpdateParts(model, on);
+    const query = `
+      UPDATE "${orm.getEntityByModel(model).tableName}"
+      SET ${clause}
+      WHERE "${orm.getEntityByModel(model).tableName}".${on} = ${idVar}
+      RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
+    `;
+    return orm.one<T>(query, values);
+  };
+
+  // Standard delete
+  const _delete = <T extends IModel>(model: T): void => {
+    const id = (model as any).id;
+    const query = `
+      DELETE FROM "${orm.getEntityByModel(model).tableName}"
+      WHERE "${orm.getEntityByModel(model).tableName}".id = $(id)
+    `;
+    return orm.none(query, { id });
+  };
+
+  const deleteMatching = <T extends IModel>(model: T) => {
+    const { whereClause, values } = getMatchingParts(model);
+    const query = `
+      DELETE FROM "${orm.getEntityByModel(model).tableName}"
+      WHERE ${whereClause};
+    `;
+    return orm.none(query, values);
+  };
+
+  const getMatching = <T extends IModel>(model: T): T => {
+    const { whereClause, values } = getMatchingParts(model);
+    const query = `
+      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
+      FROM "${orm.getEntityByModel(model).tableName}"
+      WHERE ${whereClause};
+    `;
+    return orm.one<T>(query, values);
+  };
+
+  const getOneOrNoneMatching = <T extends IModel>(model: T): T | void => {
+    const { whereClause, values } = getMatchingParts(model);
+    const query = `
+      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
+      FROM "${orm.getEntityByModel(model).tableName}"
+      WHERE ${whereClause};
+    `;
+    return orm.oneOrNone<T>(query, values);
+  };
+
+  const getAnyMatching = <T extends ICollection<IModel>>(
+    model: IModel
+  ): T | void => {
+    const { whereClause, values } = getMatchingParts(model);
+    const query = `
+      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
+      FROM "${orm.getEntityByModel(model).tableName}"
+      WHERE ${whereClause};
+    `;
+    return orm.any<T>(query, values);
+  };
+
+  const getAllMatching = <T extends ICollection<IModel>>(model: IModel): T => {
+    const { whereClause, values } = getMatchingParts(model);
+    const query = `
+      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
+      FROM "${orm.getEntityByModel(model).tableName}"
+      WHERE ${whereClause};
+    `;
+    return orm.many<T>(query, values);
+  };
+
+  return Object.assign({}, orm, {
+    // Built-in basic CRUD functions
+    create,
+    update,
+    delete: _delete,
+    deleteMatching,
+    getMatching,
+    getOneOrNoneMatching,
+    getAnyMatching,
+    getAllMatching,
+    // Helper Utility functions
+    getSqlInsertParts,
+    getSqlUpdateParts,
+    getMatchingParts,
+    getMatchingPartsObject,
+    getNewWith,
+    getValueBySqlColumn
+  });
+};

package/test-utils/blog/{orm.ts → entities.ts}

@@ -1,11 +1,11 @@
-const { create } = require('../../src/index');
 const { articleEntity } = require('./models/article');
 const { personEntity } = require('./models/person');
 const { articleTagEntity } = require('./models/article_tag');
 const { tagEntity } = require('./models/tag');
 
-const orm = create({
-  entities: [articleEntity, personEntity, articleTagEntity, tagEntity],
-  db: void 0
-});
-export default orm;
+export const entities = [
+  articleEntity,
+  personEntity,
+  articleTagEntity,
+  tagEntity
+];

package/test-utils/five/{orm.ts → entities.ts}

@@ -1,17 +1,12 @@
-import { create } from '../../src/index';
 import { orderEntity } from './models/order';
 import { lineItemEntity } from './models/line-item';
 import { parcelLineItemEntity } from './models/parcel-line-item';
 import { parcelEntity } from './models/parcel';
 import { parcelEventEntity } from './models/parcel-event';
-const orm = create({
-  entities: [
-    orderEntity,
-    lineItemEntity,
-    parcelLineItemEntity,
-    parcelEntity,
-    parcelEventEntity
-  ],
-  db: void 0
-});
-export default orm;
+export const entities = [
+  orderEntity,
+  lineItemEntity,
+  parcelLineItemEntity,
+  parcelEntity,
+  parcelEventEntity
+];

package/test-utils/nine/entities.ts

@@ -0,0 +1,2 @@
+import { featureSwitchEntity } from './models/feature-switch';
+export const entities = [featureSwitchEntity];

package/{dist/test-utils/order/orm.ts → test-utils/order/entities.ts}

@@ -1,18 +1,13 @@
-import { create } from '../../src/index';
 import { utmSourceEntity } from './models/utm-source';
 import { orderEntity } from './models/order';
 import { lineItemEntity } from './models/line-item';
 import { productVariantEntity } from './models/product-variant';
 import { productEntity } from './models/product';
 
-const orm = create({
-  entities: [
-    utmSourceEntity,
-    orderEntity,
-    lineItemEntity,
-    productVariantEntity,
-    productEntity
-  ],
-  db: void 0
-});
-export default orm;
+export const entities = [
+  utmSourceEntity,
+  orderEntity,
+  lineItemEntity,
+  productVariantEntity,
+  productEntity
+];

package/test-utils/order-more/{orm.ts → entities.ts}

@@ -1,4 +1,3 @@
-import { create } from '../../src/index';
 import { inventoryLevelEntity } from './models/inventory-level';
 import { actualProductVariantEntity } from './models/actual-product-variant';
 import { productVariantEntity } from './models/product-variant';
@@ -20,29 +19,25 @@ import { parcelLineItemEntity } from './models/parcel-line-item';
 import { parcelEntity } from './models/parcel';
 import { parcelEventEntity } from './models/parcel-event';
 
-const orm = create({
-  entities: [
-    inventoryLevelEntity,
-    actualProductVariantEntity,
-    productVariantEntity,
-    productVariantImageEntity,
-    productEntity,
-    sizeEntity,
-    colorEntity,
-    genderEntity,
-    shipmentEntity,
-    shipmentActualProductVariantEntity,
-    refundEntity,
-    orderEntity,
-    lineItemEntity,
-    customerEntity,
-    physicalAddressEntity,
-    utmSourceEntity,
-    utmMediumEntity,
-    parcelLineItemEntity,
-    parcelEntity,
-    parcelEventEntity
-  ],
-  db: void 0
-});
-export default orm;
+export const entities = [
+  inventoryLevelEntity,
+  actualProductVariantEntity,
+  productVariantEntity,
+  productVariantImageEntity,
+  productEntity,
+  sizeEntity,
+  colorEntity,
+  genderEntity,
+  shipmentEntity,
+  shipmentActualProductVariantEntity,
+  refundEntity,
+  orderEntity,
+  lineItemEntity,
+  customerEntity,
+  physicalAddressEntity,
+  utmSourceEntity,
+  utmMediumEntity,
+  parcelLineItemEntity,
+  parcelEntity,
+  parcelEventEntity
+];

package/{dist/test-utils/six/orm.ts → test-utils/six/entities.ts}

@@ -1,17 +1,12 @@
-import { create } from '../../src/index';
 import { parcelEntity } from './models/parcel';
 import { parcelLineItemEntity } from './models/parcel-line-item';
 import { lineItemEntity } from './models/line-item';
 import { orderEntity } from './models/order';
 import { customerEntity } from './models/customer';
-const orm = create({
-  entities: [
-    parcelEntity,
-    parcelLineItemEntity,
-    lineItemEntity,
-    orderEntity,
-    customerEntity
-  ],
-  db: void 0
-});
-export default orm;
+export const entities = [
+  parcelEntity,
+  parcelLineItemEntity,
+  lineItemEntity,
+  orderEntity,
+  customerEntity
+];

package/test-utils/thirteen/{orm.ts → entities.ts}

@@ -1,4 +1,3 @@
-import { create } from '../../src/index';
 import { memberEntity } from './models/member';
 import { recommendationEntity } from './models/recommendation';
 import { brandEntity } from './models/brand';
@@ -7,17 +6,13 @@ import { categoryEntity } from './models/category';
 import { passionEntity } from './models/passion';
 import { recommendationAudienceEntity } from './models/recommendation-audience';
 import { audienceEntity } from './models/audience';
-const orm = create({
-  entities: [
-    memberEntity,
-    recommendationEntity,
-    brandEntity,
-    productEntity,
-    categoryEntity,
-    passionEntity,
-    recommendationAudienceEntity,
-    audienceEntity
-  ],
-  db: void 0
-});
-export default orm;
+export const entities = [
+  memberEntity,
+  recommendationEntity,
+  brandEntity,
+  productEntity,
+  categoryEntity,
+  passionEntity,
+  recommendationAudienceEntity,
+  audienceEntity
+];

package/test-utils/twelve/entities.ts

@@ -0,0 +1,3 @@
+import { promptEntity } from './models/prompt';
+import { memberEntity } from './models/member';
+export const entities = [promptEntity, memberEntity];

package/dist/src/factory.d.ts

@@ -1,100 +0,0 @@
-export interface IColumnData {
-    column: string;
-    property?: string;
-    references?: IModelClass;
-    primaryKey?: boolean;
-}
-export declare type IColumn = IColumnData | string;
-export declare type IColumns = Array<IColumn> | (() => Array<IColumn>);
-export interface IColumnInternalData {
-    column: string;
-    property: string;
-    references?: IModelClass;
-    primaryKey: boolean;
-}
-export declare type IColumnInternal = IColumnInternalData;
-export declare type IColumnsInternal = Array<IColumnInternal>;
-export interface IModel {
-    [key: string]: any;
-}
-export declare type IModelClass = new (props: any) => IModel;
-export interface ICollection<T extends IModel> {
-    models: Array<T>;
-}
-export interface IEntity<T extends IModel> {
-    tableName: string;
-    displayName?: string;
-    collectionDisplayName?: string;
-    columns: IColumns;
-    Model: new (props: any) => T;
-    Collection: new ({ models }: any) => ICollection<T>;
-}
-export declare type IEntities<T extends IModel> = Array<IEntity<T>>;
-export interface IEntityInternal<T extends IModel> {
-    tableName: string;
-    displayName: string;
-    collectionDisplayName: string;
-    columns: IColumnsInternal;
-    propertyNames: Array<string>;
-    Model: new (props: any) => T;
-    Collection: new ({ models }: any) => ICollection<T>;
-    columnNames: Array<string>;
-    prefixedColumnNames: Array<string>;
-    primaryKeys: Array<string>;
-    references: object;
-    selectColumnsClause: string;
-    getPkId: (model: IModel) => string;
-}
-export declare type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
-export interface CreateOptions {
-    entities: IEntities<IModel>;
-    db: any;
-    logError?: (err: Error) => void;
-}
-export declare const create: ({ entities: externalEntities, db, logError }: CreateOptions) => {
-    nestClump: (clump: Array<Array<IModel>>) => object;
-    clumpIntoGroups: (processed: Array<Array<IModel>>) => Array<Array<Array<IModel>>>;
-    mapToBos: (objectified: any) => IModel[];
-    objectifyDatabaseResult: (result: object) => any;
-    createFromDatabase: <T extends ICollection<IModel>>(_result: Array<object> | object) => T | undefined;
-    createOneFromDatabase: <T_1 extends IModel>(_result: any) => T_1;
-    createOneOrNoneFromDatabase: <T_2 extends IModel>(_result: any) => void | T_2;
-    createManyFromDatabase: <T_3 extends ICollection<IModel>>(_result: any) => T_3;
-    getSqlInsertParts: (model: IModel) => {
-        columns: string;
-        values: any[];
-        valuesVar: string[];
-    };
-    getSqlUpdateParts: (model: IModel, on?: string) => {
-        clause: string;
-        idVar: string;
-        values: any[];
-    };
-    getMatchingParts: (model: IModel) => {
-        whereClause: string;
-        values: any[];
-    };
-    getMatchingPartsObject: (model: IModel) => {
-        whereClause: string;
-        values: any;
-    };
-    getNewWith: (model: IModel, sqlColumns: any, values: any) => any;
-    getValueBySqlColumn: (model: IModel, sqlColumn: string) => any;
-    one: <T_4 extends IModel>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => T_4;
-    oneOrNone: <T_5 extends IModel>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void | T_5;
-    many: <T_6 extends ICollection<IModel>>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => T_6;
-    any: <T_7 extends ICollection<IModel>>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void | T_7;
-    none: (query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void;
-    create: <T_8 extends IModel>(model: T_8) => T_8;
-    update: <T_9 extends IModel>(model: T_9, { on }?: {
-        on?: string | undefined;
-    }) => T_9;
-    delete: <T_10 extends IModel>(model: T_10) => void;
-    deleteMatching: <T_11 extends IModel>(model: T_11) => void;
-    getMatching: <T_12 extends IModel>(model: T_12) => T_12;
-    getOneOrNoneMatching: <T_13 extends IModel>(model: T_13) => void | T_13;
-    getAnyMatching: <T_14 extends ICollection<IModel>>(model: IModel) => void | T_14;
-    getAllMatching: <T_15 extends ICollection<IModel>>(model: IModel) => T_15;
-    tables: any;
-    db: any;
-};

package/dist/test-utils/blog/orm.d.ts

@@ -1,2 +0,0 @@
-declare const orm: any;
-export default orm;

package/dist/test-utils/five/orm.d.ts

@@ -1,48 +0,0 @@
-declare const orm: {
-    nestClump: (clump: import("../../src/factory").IModel[][]) => object;
-    clumpIntoGroups: (processed: import("../../src/factory").IModel[][]) => import("../../src/factory").IModel[][][];
-    mapToBos: (objectified: any) => import("../../src/factory").IModel[];
-    objectifyDatabaseResult: (result: object) => any;
-    createFromDatabase: <T extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(_result: object | object[]) => T | undefined;
-    createOneFromDatabase: <T_1 extends import("../../src/factory").IModel>(_result: any) => T_1;
-    createOneOrNoneFromDatabase: <T_2 extends import("../../src/factory").IModel>(_result: any) => void | T_2;
-    createManyFromDatabase: <T_3 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(_result: any) => T_3;
-    getSqlInsertParts: (model: import("../../src/factory").IModel) => {
-        columns: string;
-        values: any[];
-        valuesVar: string[];
-    };
-    getSqlUpdateParts: (model: import("../../src/factory").IModel, on?: string) => {
-        clause: string;
-        idVar: string;
-        values: any[];
-    };
-    getMatchingParts: (model: import("../../src/factory").IModel) => {
-        whereClause: string;
-        values: any[];
-    };
-    getMatchingPartsObject: (model: import("../../src/factory").IModel) => {
-        whereClause: string;
-        values: any;
-    };
-    getNewWith: (model: import("../../src/factory").IModel, sqlColumns: any, values: any) => any;
-    getValueBySqlColumn: (model: import("../../src/factory").IModel, sqlColumn: string) => any;
-    one: <T_4 extends import("../../src/factory").IModel>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => T_4;
-    oneOrNone: <T_5 extends import("../../src/factory").IModel>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void | T_5;
-    many: <T_6 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => T_6;
-    any: <T_7 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void | T_7;
-    none: (query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void;
-    create: <T_8 extends import("../../src/factory").IModel>(model: T_8) => T_8;
-    update: <T_9 extends import("../../src/factory").IModel>(model: T_9, { on }?: {
-        on?: string | undefined;
-    }) => T_9;
-    delete: <T_10 extends import("../../src/factory").IModel>(model: T_10) => void;
-    deleteMatching: <T_11 extends import("../../src/factory").IModel>(model: T_11) => void;
-    getMatching: <T_12 extends import("../../src/factory").IModel>(model: T_12) => T_12;
-    getOneOrNoneMatching: <T_13 extends import("../../src/factory").IModel>(model: T_13) => void | T_13;
-    getAnyMatching: <T_14 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(model: import("../../src/factory").IModel) => void | T_14;
-    getAllMatching: <T_15 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(model: import("../../src/factory").IModel) => T_15;
-    tables: any;
-    db: any;
-};
-export default orm;