Merge pull request #159 from hemedani/main

implement exclude option

examples/whyLesan/performance.ts

@@ -0,0 +1,354 @@
+import {
+ ActFn,
+ lesan,
+ MongoClient,
+ number,
+ object,
+ ObjectId,
+ objectIdValidation,
+ RelationDataType,
+ RelationSortOrderType,
+ string,
+} from "../../mod.ts";
+
+const coreApp = lesan();
+
+const client = await new MongoClient("mongodb:https://127.0.0.1:27017/").connect();
+
+const db = client.db("performance");
+
+coreApp.odm.setDb(db);
+
+// ================== MODEL SECTION ==================
+// ------------------ Country Model ------------------
+const pure = {
+ name: string(),
+ population: number(),
+ abb: string(),
+};
+const countryRelations = {};
+const countries = coreApp.odm.newModel(
+ "country",
+ pure,
+ countryRelations,
+);
+
+// ------------------ Province Model ------------------
+const provinceRelations = {
+ country: {
+ optional: false,
+ schemaName: "country",
+ type: "single" as RelationDataType,
+ relatedRelations: {
+ provinces: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "_id",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ provincesByPopulation: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "population",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ },
+ },
+};
+
+const provinces = coreApp.odm.newModel(
+ "province",
+ pure,
+ provinceRelations,
+);
+
+// ------------------ City Model ------------------
+const cityRelations = {
+ country: {
+ optional: false,
+ schemaName: "country",
+ type: "single" as RelationDataType,
+ relatedRelations: {
+ cities: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "_id",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ citiesByPopulation: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "population",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ },
+ },
+ province: {
+ optional: false,
+ schemaName: "province",
+ type: "single" as RelationDataType,
+ relatedRelations: {
+ cities: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "_id",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ citiesByPopulation: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "population",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ },
+ },
+};
+
+const cities = coreApp.odm.newModel(
+ "city",
+ pure,
+ cityRelations,
+);
+
+// ------------------ User Model ------------------
+const userPure = {
+ name: string(),
+ family: string(),
+ age: number(),
+};
+
+const userRelations = {
+ country: {
+ optional: false,
+ schemaName: "country",
+ type: "single" as RelationDataType,
+ relatedRelations: {
+ users: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "_id",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ usersByAge: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "age",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ },
+ },
+ province: {
+ optional: false,
+ schemaName: "province",
+ type: "single" as RelationDataType,
+ relatedRelations: {
+ users: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "_id",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ usersByAge: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "age",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ },
+ },
+ city: {
+ optional: false,
+ schemaName: "city",
+ type: "single" as RelationDataType,
+ relatedRelations: {
+ users: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "_id",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ usersByAge: {
+ type: "multiple" as RelationDataType,
+ limit: 50,
+ sort: {
+ field: "age",
+ order: "desc" as RelationSortOrderType,
+ },
+ },
+ },
+ },
+};
+
+const users = coreApp.odm.newModel(
+ "user",
+ userPure,
+ userRelations,
+);
+
+// ================== FUNCTIONS SECTION ==================
+// ------------------ Country Founctions ------------------
+// ------------------ Add Country ------------------
+const addCountryValidator = () => {
+ return object({
+ set: object(pure),
+ get: coreApp.schemas.selectStruct("country", 1),
+ });
+};
+
+const addCountry: ActFn = async (body) => {
+ const { name, population, abb } = body.details.set;
+ return await countries.insertOne({
+ doc: {
+ name,
+ population,
+ abb,
+ },
+ projection: body.details.get,
+ });
+};
+
+coreApp.acts.setAct({
+ schema: "country",
+ actName: "addCountry",
+ validator: addCountryValidator(),
+ fn: addCountry,
+});
+
+// ------------------ get Countries ------------------
+const getCountriesValidator = () => {
+ return object({
+ set: object({}),
+ get: coreApp.schemas.selectStruct("country", 2),
+ });
+};
+const getCountries: ActFn = async (body) => {
+ const {
+ set,
+ get,
+ } = body.details;
+
+ return await countries
+ .aggregation({
+ pipeline: [],
+ projection: get,
+ })
+ .toArray();
+};
+
+coreApp.acts.setAct({
+ schema: "country",
+ actName: "getCountries",
+ validator: getCountriesValidator(),
+ fn: getCountries,
+});
+
+// ------------------ Province Founctions ------------------
+// ------------------ Add Propvince ------------------
+const addProvinceValidator = () => {
+ return object({
+ set: object({
+ ...pure,
+ countryId: objectIdValidation,
+ }),
+ get: coreApp.schemas.selectStruct("province", 1),
+ });
+};
+
+const addProvince: ActFn = async (body) => {
+ const { name, population, abb, countryId } = body.details.set;
+ return await provinces.insertOne({
+ doc: {
+ name,
+ population,
+ abb,
+ },
+ relations: {
+ country: {
+ _ids: new ObjectId(countryId),
+ relatedRelations: {
+ provinces: true,
+ provincesByPopulation: true,
+ },
+ },
+ },
+ projection: body.details.get,
+ });
+};
+
+coreApp.acts.setAct({
+ schema: "province",
+ actName: "addProvince",
+ validator: addProvinceValidator(),
+ fn: addProvince,
+});
+
+// ------------------ City Founctions ------------------
+// ------------------ Add City ------------------
+const addCityValidator = () => {
+ return object({
+ set: object({
+ ...pure,
+ countryId: objectIdValidation,
+ provinceId: objectIdValidation,
+ }),
+ get: coreApp.schemas.selectStruct("city", 1),
+ });
+};
+
+const addCity: ActFn = async (body) => {
+ const { name, population, abb, countryId, provinceId } = body.details.set;
+
+ return await cities.insertOne({
+ doc: {
+ name,
+ population,
+ abb,
+ },
+ relations: {
+ country: {
+ _ids: new ObjectId(countryId),
+ relatedRelations: {
+ cities: true,
+ citiesByPopulation: true,
+ },
+ },
+ province: {
+ _ids: new ObjectId(provinceId),
+ relatedRelations: {
+ cities: true,
+ citiesByPopulation: true,
+ },
+ },
+ },
+ projection: body.details.get,
+ });
+};
+
+coreApp.acts.setAct({
+ schema: "city",
+ actName: "addCity",
+ validator: addCityValidator(),
+ fn: addCity,
+});

src/models/pure/getPureModel.ts

@@ -1,4 +1,5 @@
 import { throwError } from "../../utils/throwError.ts";
+import { getPureSchema } from "../mod.ts";
 import { schemaFns, TSchemas } from "../mod.ts";
 
 /**
@@ -8,6 +9,6 @@ import { schemaFns, TSchemas } from "../mod.ts";
 export const getPureModel = (schemasObj: TSchemas, name: string) => {
  const schemas = schemaFns(schemasObj).getSchemas();
  return schemas[name]
- ? schemas[name].pure
+ ? getPureSchema(schemas, name)
  : throwError(`Schema ${name} is not exist in the Schema Object`);
 };

src/models/schema/createStruct.ts

@@ -1,7 +1,7 @@
 import { assign, object } from "../../npmDeps.ts";
 import { createEmbedded } from "./createEmbedded.ts";
 import { getSchema } from "./getSchema.ts";
-import { TSchemas } from "./mod.ts";
+import { getPureSchema, TSchemas } from "./mod.ts";
 
 /**
  * create struct features, struct feature is used for create client of db.
@@ -29,9 +29,8 @@ import { TSchemas } from "./mod.ts";
  * ),
  */
 export const createStruct = (schemas: TSchemas, schemaName: string) => {
- const schema = getSchema(schemas, schemaName);
  return assign(
- object(schema.pure),
+ object(getPureSchema(schemas, schemaName)),
  object(createEmbedded(schemas, schemaName)),
  );
 };