pure-orm 4.0.0-0 → 4.0.0-3

package/dist/example/app.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/example/app.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const person_1 = require("./data-access/person");
+const app = (0, express_1.default)();
+const port = process.env.PORT;
+app.get('/rest/person', (req, res) => {
+    const person = (0, person_1.getPerson)(+req.params.id);
+    res.json(person);
+});
+app.listen(port);

package/dist/example/data-access/person.d.ts

@@ -0,0 +1,2 @@
+import { Person } from '../models/person';
+export declare const getPerson: (id: number) => Person;

package/dist/example/data-access/person.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPerson = void 0;
+const orm_1 = __importDefault(require("../factories/orm"));
+const getPerson = (id) => {
+    const query = `
+    SELECT
+      ${orm_1.default.tables.person.columns},
+      ${orm_1.default.tables.job.columns},
+      ${orm_1.default.tables.employer.columns}
+    FROM person
+    LEFT JOIN job on person.id = job.person_id
+    LEFT JOIN employer on job.employer_id = employer.id
+    WHERE id = $(id)
+  `;
+    return orm_1.default.one(query, { id });
+};
+exports.getPerson = getPerson;

package/dist/example/factories/db.d.ts

@@ -0,0 +1,2 @@
+import pgPromise from 'pg-promise';
+export declare const db: pgPromise.IDatabase<{}, import("pg-promise/typescript/pg-subset").IClient>;

package/dist/example/factories/db.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = void 0;
+const pg_promise_1 = __importDefault(require("pg-promise"));
+const pgp = (0, pg_promise_1.default)();
+const connectionObject = {
+    host: process.env.DB_HOSTNAME,
+    port: process.env.DB_PORT ? +process.env.DB_PORT : void 0,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+};
+exports.db = pgp(connectionObject);

package/dist/example/factories/orm.d.ts

@@ -0,0 +1,47 @@
+declare const orm: {
+    nestClump: (clump: import("../../src/factory").IModel[][]) => object;
+    clumpIntoGroups: (processed: import("../../src/factory").IModel[][]) => import("../../src/factory").IModel[][][];
+    mapToBos: (objectified: any) => any[];
+    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;
+};
+export default orm;

package/dist/example/factories/orm.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../src/index");
+const db_1 = require("./db");
+const person_1 = require("../models/person");
+const job_1 = require("../models/job");
+const employer_1 = require("../models/employer");
+const orm = (0, index_1.create)({
+    entities: [person_1.personEntity, job_1.jobEntity, employer_1.employerEntity],
+    db: db_1.db
+});
+exports.default = orm;

package/dist/example/models/employer.d.ts

@@ -0,0 +1,23 @@
+import { IModel, ICollection, IColumns } from '../../src/index';
+export declare const tableName: string;
+export declare const columns: IColumns;
+interface IEmployerProps {
+    id: number;
+    name: string;
+}
+export declare class Employer implements IModel {
+    id: number;
+    name: string;
+    constructor(props: IEmployerProps);
+}
+export declare class Employers implements ICollection<Employer> {
+    models: Array<Employer>;
+    constructor({ models }: any);
+}
+export declare const employerEntity: {
+    tableName: string;
+    columns: IColumns;
+    Model: typeof Employer;
+    Collection: typeof Employers;
+};
+export {};

package/dist/example/models/employer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.employerEntity = exports.Employers = exports.Employer = exports.columns = exports.tableName = void 0;
+exports.tableName = 'employer';
+exports.columns = ['id', 'name'];
+class Employer {
+    constructor(props) {
+        this.id = props.id;
+        this.name = props.name;
+    }
+}
+exports.Employer = Employer;
+class Employers {
+    constructor({ models }) {
+        this.models = models;
+        return this;
+    }
+}
+exports.Employers = Employers;
+exports.employerEntity = {
+    tableName: exports.tableName,
+    columns: exports.columns,
+    Model: Employer,
+    Collection: Employers
+};

package/dist/example/models/job.d.ts

@@ -0,0 +1,35 @@
+import { IModel, ICollection, IColumns } from '../../src/index';
+import { Person } from './person';
+import { Employer } from './employer';
+export declare const tableName: string;
+export declare const columns: IColumns;
+interface IJobProps {
+    id: number;
+    personId: number;
+    person?: Person;
+    employerId: number;
+    employer?: Employer;
+    startDate: Date;
+    endDate: Date;
+}
+export declare class Job implements IModel {
+    id: number;
+    personId: number;
+    person?: Person;
+    employerId: number;
+    employer?: Employer;
+    startDate: Date;
+    endDate: Date;
+    constructor(props: IJobProps);
+}
+export declare class Jobs implements ICollection<Job> {
+    models: Array<Job>;
+    constructor({ models }: any);
+}
+export declare const jobEntity: {
+    tableName: string;
+    columns: IColumns;
+    Model: typeof Job;
+    Collection: typeof Jobs;
+};
+export {};

package/dist/example/models/job.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobEntity = exports.Jobs = exports.Job = exports.columns = exports.tableName = void 0;
+const person_1 = require("./person");
+const employer_1 = require("./employer");
+exports.tableName = 'job';
+exports.columns = [
+    'id',
+    { column: 'person_id', references: person_1.Person },
+    { column: 'employer_id', references: employer_1.Employer },
+    'start_date',
+    'end_date'
+];
+class Job {
+    constructor(props) {
+        this.id = props.id;
+        this.personId = props.personId;
+        this.person = props.person;
+        this.employerId = props.employerId;
+        this.employer = props.employer;
+        this.startDate = props.startDate;
+        this.endDate = props.endDate;
+    }
+}
+exports.Job = Job;
+class Jobs {
+    constructor({ models }) {
+        this.models = models;
+        return this;
+    }
+}
+exports.Jobs = Jobs;
+exports.jobEntity = {
+    tableName: exports.tableName,
+    columns: exports.columns,
+    Model: Job,
+    Collection: Jobs
+};

package/dist/example/models/person.d.ts

@@ -0,0 +1,25 @@
+import { IModel, ICollection, IColumns } from '../../src/index';
+export declare const tableName: string;
+export declare const columns: IColumns;
+interface IPersonProps {
+    id: number;
+    name: string;
+}
+export declare class Person implements IModel {
+    id: number;
+    name: string;
+    constructor(props: IPersonProps);
+    sayHello(): void;
+}
+export declare class Persons implements ICollection<Person> {
+    models: Array<Person>;
+    constructor({ models }: any);
+    introductions(): void;
+}
+export declare const personEntity: {
+    tableName: string;
+    columns: IColumns;
+    Model: typeof Person;
+    Collection: typeof Persons;
+};
+export {};

package/dist/example/models/person.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.personEntity = exports.Persons = exports.Person = exports.columns = exports.tableName = void 0;
+exports.tableName = 'person';
+exports.columns = ['id', 'name'];
+class Person {
+    constructor(props) {
+        this.id = props.id;
+        this.name = props.name;
+    }
+    sayHello() {
+        console.log(`${this.name} says hi!`);
+    }
+}
+exports.Person = Person;
+class Persons {
+    constructor({ models }) {
+        this.models = models;
+        return this;
+    }
+    introductions() {
+        this.models.forEach((person) => person.sayHello());
+    }
+}
+exports.Persons = Persons;
+exports.personEntity = {
+    tableName: exports.tableName,
+    columns: exports.columns,
+    Model: Person,
+    Collection: Persons
+};

package/dist/src/factory.d.ts

@@ -0,0 +1,99 @@
+export interface IColumnData {
+    column: string;
+    property?: string;
+    references?: IModelClass;
+    primaryKey?: boolean;
+}
+export declare type IColumn = IColumnData | string;
+export declare type IColumns = 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<any>;
+    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) => any[];
+    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;
+};