@digione/node-custom-api 0.0.1

package/models/core/site.d.ts

@@ -0,0 +1,60 @@
+import * as sequelize from "sequelize";
+export declare const CoreSiteAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    created_by: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    name: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    ref: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+        unique: boolean;
+    };
+    domain: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+        unique: boolean;
+    };
+    active: {
+        type: sequelize.TinyIntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    created_on: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    updated_on: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    tag_id: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    group_id: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    c_path: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+};
+declare const CoreSiteModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { CoreSiteModel };

package/models/core/site.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreSiteModel = exports.CoreSiteAttr = void 0;
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const helper_1 = require("../../utils/helper");
+exports.CoreSiteAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 5 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    created_by: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 1
+    },
+    name: {
+        type: sequelize.STRING(100),
+        allowNull: false
+    },
+    ref: {
+        type: sequelize.STRING(20),
+        allowNull: false,
+        unique: true
+    },
+    domain: {
+        type: sequelize.STRING(100),
+        allowNull: false,
+        unique: true
+    },
+    active: {
+        type: sequelize.TINYINT({ length: 1 }),
+        allowNull: false,
+        defaultValue: 1
+    },
+    created_on: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 0
+    },
+    updated_on: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 0
+    },
+    tag_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 1
+    },
+    group_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 0
+    },
+    c_path: {
+        type: sequelize.INTEGER({ length: 5 }),
+        allowNull: false,
+        defaultValue: 0
+    }
+};
+const CoreSiteModel = database_1.default.define("CoreSites", exports.CoreSiteAttr, {
+    tableName: 'sites'
+});
+exports.CoreSiteModel = CoreSiteModel;
+CoreSiteModel.beforeCreate((model, options) => {
+    model.setDataValue('created_on', Number((0, helper_1.getDateTime)().format('X')));
+});

package/models/core/state.d.ts

@@ -0,0 +1,49 @@
+import * as sequelize from "sequelize";
+export declare const StateTable = "states";
+export declare const StateAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    state_name: sequelize.StringDataType;
+    country_id: sequelize.IntegerDataType;
+    status: sequelize.IntegerDataType;
+    ordering: sequelize.IntegerDataType;
+    lang_code: sequelize.StringDataType;
+};
+declare const StateModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+declare const StateAssociation: {
+    zone: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes, required }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+    zone_country: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes, required }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+};
+export { StateModel, StateAssociation };

package/models/core/state.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAssociation = exports.StateModel = exports.StateAttr = exports.StateTable = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const zone_1 = require("../system/zone");
+exports.StateTable = "states";
+exports.StateAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    state_name: sequelize.STRING(200),
+    country_id: sequelize.INTEGER({ length: 11 }),
+    status: sequelize.INTEGER({ length: 11 }),
+    ordering: sequelize.INTEGER({ length: 11 }),
+    lang_code: sequelize.STRING(20)
+};
+const StateModel = database_1.default.define("State", exports.StateAttr, {
+    tableName: exports.StateTable
+});
+exports.StateModel = StateModel;
+const StateAssociation = {
+    zone: {
+        model: zone_1.ZoneStateModel,
+        alias: "zone",
+        join: (ref, { where = {}, attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: StateAssociation.zone.model.schema(ref, "_"),
+                as: StateAssociation.zone.alias
+            };
+        })
+    },
+    zone_country: {
+        model: zone_1.ZoneCountryModel,
+        alias: "zone_country",
+        join: (ref, { where = {}, attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: StateAssociation.zone_country.model.schema(ref, "_"),
+                as: StateAssociation.zone_country.alias
+            };
+        })
+    }
+};
+exports.StateAssociation = StateAssociation;
+// zone
+StateModel.hasOne(StateAssociation.zone.model, { as: StateAssociation.zone.alias, foreignKey: "state_id" });
+// zone country
+StateModel.belongsTo(StateAssociation.zone_country.model, { as: StateAssociation.zone_country.alias, foreignKey: "country_id", targetKey: "country_id" });

package/models/core/zipcode.d.ts

@@ -0,0 +1,5 @@
+import * as sequelize from "sequelize";
+export declare const ZipcodeTable = "zipcodes";
+export declare const ZipcodeAttr: sequelize.ModelAttributes<sequelize.Model<any, any>, any>;
+declare const ZipcodeModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { ZipcodeModel };

package/models/core/zipcode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipcodeModel = exports.ZipcodeAttr = exports.ZipcodeTable = void 0;
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+exports.ZipcodeTable = "zipcodes";
+exports.ZipcodeAttr = {
+    city_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        allowNull: false
+    },
+    district_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        allowNull: false
+    },
+    code: {
+        type: sequelize.STRING(100),
+        primaryKey: true,
+        allowNull: false
+    },
+    state_id: sequelize.INTEGER({ length: 11 })
+};
+const ZipcodeModel = database_1.default.define("Zipcode", exports.ZipcodeAttr, {
+    tableName: exports.ZipcodeTable
+});
+exports.ZipcodeModel = ZipcodeModel;

package/models/stream/field.d.ts

@@ -0,0 +1,60 @@
+import * as sequelize from "sequelize";
+export declare const FieldTable = "data_fields";
+export declare const FieldAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+        autoIncrement: boolean;
+    };
+    sort_order: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+    };
+    stream_id: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+    };
+    is_required: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        defaultValue: string;
+    };
+    is_unique: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        defaultValue: string;
+    };
+    is_lang: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        defaultValue: string;
+    };
+    special: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        defaultValue: string;
+    };
+    field_name: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    field_slug: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    field_type: {
+        type: sequelize.StringDataType;
+    };
+    field_data: sequelize.TextDataType;
+    view_options: sequelize.TextDataType;
+    is_locked: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        allowNull: boolean;
+        defaultValue: string;
+    };
+    instructions: {
+        type: sequelize.TextDataTypeConstructor;
+    };
+    group: sequelize.StringDataType;
+    condition: sequelize.StringDataType;
+    section_id: sequelize.IntegerDataTypeConstructor;
+};
+declare const FieldModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { FieldModel };

package/models/stream/field.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldModel = exports.FieldAttr = exports.FieldTable = void 0;
+const database_1 = require("../../database");
+const sequelize = require("sequelize");
+exports.FieldTable = "data_fields";
+exports.FieldAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }).UNSIGNED,
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: true
+    },
+    sort_order: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false
+    },
+    stream_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false
+    },
+    is_required: {
+        type: sequelize.ENUM('yes', 'no'),
+        defaultValue: 'no'
+    },
+    is_unique: {
+        type: sequelize.ENUM('yes', 'no'),
+        defaultValue: 'no'
+    },
+    is_lang: {
+        type: sequelize.ENUM('yes', 'no'),
+        defaultValue: 'no'
+    },
+    special: {
+        type: sequelize.ENUM('yes', 'no'),
+        defaultValue: 'no'
+    },
+    field_name: {
+        type: sequelize.STRING(60),
+        allowNull: false
+    },
+    field_slug: {
+        type: sequelize.STRING(60),
+        allowNull: false
+    },
+    field_type: {
+        type: sequelize.STRING(50)
+    },
+    field_data: sequelize.TEXT('long'),
+    view_options: sequelize.TEXT('medium'),
+    is_locked: {
+        type: sequelize.ENUM('yes', 'no'),
+        allowNull: false,
+        defaultValue: 'no'
+    },
+    instructions: {
+        type: sequelize.TEXT
+    },
+    group: sequelize.STRING(255),
+    condition: sequelize.STRING(255),
+    section_id: sequelize.INTEGER
+};
+const FieldModel = database_1.default.define("Field", exports.FieldAttr, {
+    tableName: exports.FieldTable
+});
+exports.FieldModel = FieldModel;

package/models/stream/field_section.d.ts

@@ -0,0 +1,33 @@
+import * as sequelize from "sequelize";
+export declare const FieldSectionTable = "data_field_sections";
+export declare const FieldSectionAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+        autoIncrement: boolean;
+    };
+    ordering_count: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+    };
+    stream_id: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+    };
+    title: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    field_width: {
+        type: sequelize.TinyIntegerDataType;
+        defaultValue: number;
+    };
+    status: {
+        type: sequelize.StringDataType;
+        defaultValue: string;
+    };
+    index: sequelize.StringDataType;
+};
+declare const FieldSectionModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { FieldSectionModel };

package/models/stream/field_section.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSectionModel = exports.FieldSectionAttr = exports.FieldSectionTable = void 0;
+const database_1 = require("../../database");
+const sequelize = require("sequelize");
+exports.FieldSectionTable = "data_field_sections";
+exports.FieldSectionAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }).UNSIGNED,
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: true
+    },
+    ordering_count: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false
+    },
+    stream_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false
+    },
+    title: {
+        type: sequelize.STRING(255),
+        allowNull: false
+    },
+    field_width: {
+        type: sequelize.TINYINT({ length: 1 }),
+        defaultValue: 0
+    },
+    status: {
+        type: sequelize.STRING(10),
+        defaultValue: "show"
+    },
+    index: sequelize.STRING(60)
+};
+const FieldSectionModel = database_1.default.define("FieldSection", exports.FieldSectionAttr, {
+    tableName: exports.FieldSectionTable
+});
+exports.FieldSectionModel = FieldSectionModel;

package/models/stream/stream.d.ts

@@ -0,0 +1,89 @@
+import * as sequelize from "sequelize";
+export declare const StreamTable = "data_streams";
+export declare const StreamAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+        autoIncrement: boolean;
+    };
+    stream_name: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    stream_slug: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    stream_namespace: {
+        type: sequelize.StringDataType;
+    };
+    stream_prefix: {
+        type: sequelize.StringDataType;
+    };
+    stream_type: {
+        type: sequelize.EnumDataType<"auto" | "manual">;
+        defaultValue: string;
+    };
+    about: {
+        type: sequelize.StringDataType;
+    };
+    view_options: sequelize.TextDataType;
+    title_column: {
+        type: sequelize.StringDataType;
+    };
+    sorting: {
+        type: sequelize.EnumDataType<"custom" | "title">;
+        allowNull: boolean;
+        defaultValue: string;
+    };
+    permissions: {
+        type: sequelize.TextDataTypeConstructor;
+    };
+    is_hidden: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        allowNull: boolean;
+        defaultValue: string;
+    };
+    is_locked: {
+        type: sequelize.EnumDataType<"no" | "yes">;
+        allowNull: boolean;
+        defaultValue: string;
+    };
+};
+declare const StreamModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export declare const FieldAssociation: {
+    stream: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: string, { where, attributes, required }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+};
+export declare const StreamAssociation: {
+    field: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: string, { where, attributes, required }?: {
+            where?: {};
+            attributes?: string[];
+            required?: any;
+        }) => {
+            where: {};
+            required: any;
+            attributes: string[];
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        };
+    };
+};
+export { StreamModel };

package/models/stream/stream.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamModel = exports.StreamAssociation = exports.FieldAssociation = exports.StreamAttr = exports.StreamTable = void 0;
+const tslib_1 = require("tslib");
+const database_1 = require("../../database");
+const sequelize = require("sequelize");
+const field_1 = require("./field");
+exports.StreamTable = "data_streams";
+exports.StreamAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 10 }).UNSIGNED,
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: true
+    },
+    stream_name: {
+        type: sequelize.STRING(60),
+        allowNull: false
+    },
+    stream_slug: {
+        type: sequelize.STRING(60),
+        allowNull: false
+    },
+    stream_namespace: {
+        type: sequelize.STRING(60)
+    },
+    stream_prefix: {
+        type: sequelize.STRING(60)
+    },
+    stream_type: {
+        type: sequelize.ENUM('auto', 'manual'),
+        defaultValue: "auto"
+    },
+    about: {
+        type: sequelize.STRING(255)
+    },
+    view_options: sequelize.TEXT('medium'),
+    title_column: {
+        type: sequelize.STRING(255)
+    },
+    sorting: {
+        type: sequelize.ENUM('title', 'custom'),
+        allowNull: false,
+        defaultValue: "title"
+    },
+    permissions: {
+        type: sequelize.TEXT
+    },
+    is_hidden: {
+        type: sequelize.ENUM('yes', 'no'),
+        allowNull: false,
+        defaultValue: "no"
+    },
+    is_locked: {
+        type: sequelize.ENUM('yes', 'no'),
+        allowNull: false,
+        defaultValue: "no"
+    }
+};
+const StreamModel = database_1.default.define("Stream", exports.StreamAttr, {
+    tableName: exports.StreamTable
+});
+exports.StreamModel = StreamModel;
+exports.FieldAssociation = {
+    stream: {
+        model: StreamModel,
+        alias: "stream",
+        join: (ref, { where = {}, attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: exports.FieldAssociation.stream.model.schema(ref, "_"),
+                as: exports.FieldAssociation.stream.alias
+            };
+        })
+    }
+};
+exports.StreamAssociation = {
+    field: {
+        model: field_1.FieldModel,
+        alias: 'fields',
+        join: (ref, { where = {}, attributes = ['id', 'is_required', 'is_lang', 'sort_order', 'field_name', 'field_slug', 'field_type', 'field_data', 'group', 'condition', 'section_id', 'instructions'], required = undefined } = {}) => {
+            return {
+                where,
+                required,
+                attributes,
+                model: exports.StreamAssociation.field.model.schema(ref, '_'),
+                as: exports.StreamAssociation.field.alias,
+            };
+        }
+    }
+};
+// field
+StreamModel.hasMany(exports.StreamAssociation.field.model, { as: exports.StreamAssociation.field.alias, foreignKey: 'stream_id' });
+// stream
+field_1.FieldModel.belongsTo(exports.FieldAssociation.stream.model, { as: exports.FieldAssociation.stream.alias, foreignKey: 'stream_id' });

package/models/system/currency.d.ts

@@ -0,0 +1,5 @@
+import * as sequelize from "sequelize";
+export declare const SystemCurrencyTable = "currency";
+export declare const SystemCurrencyAttr: sequelize.ModelAttributes<sequelize.Model<any, any>, any>;
+declare const SystemCurrencyModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { SystemCurrencyModel };