@bedrockio/model 0.1.0 → 0.1.1

package/types/search.d.ts

@@ -0,0 +1,303 @@
+export function applySearch(schema: any, definition: any): void;
+export function searchValidation(definition: any, options?: {}): {
+    ids: {
+        setup: any;
+        length(length: any): any;
+        min(length: any): any;
+        max(length: any): any;
+        latlng(): any;
+        assertions: any[];
+        meta: {};
+        required(): any;
+        default(value: any): any;
+        custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+        strip(strip: any): any;
+        allow(...set: any[]): any;
+        reject(...set: any[]): any;
+        message(message: any): any;
+        tag(tags: any): any;
+        description(description: any): any;
+        options(options: any): any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): any;
+        append(schema: any): any;
+        toOpenApi(extra: any): any;
+        assertEnum(set: any, allow: any): any;
+        assert(type: any, fn: any): any;
+        pushAssertion(assertion: any): void;
+        transform(fn: any): any;
+        getSortIndex(type: any): number;
+        runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+        enumToOpenApi(): {
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            enum: any;
+            oneOf?: undefined;
+        } | {
+            oneOf: any[];
+            type?: undefined;
+            enum?: undefined;
+        };
+    };
+    keyword: {
+        min(length: number): any;
+        max(length: number): any;
+        trim(): any;
+        lowercase(assert?: boolean): any;
+        uppercase(assert?: boolean): any;
+        match(reg: RegExp): any;
+        email(): any;
+        phone(): any;
+        hex(): any;
+        md5(): any;
+        sha1(): any;
+        ascii(): any;
+        base64(options?: {
+            urlSafe?: boolean;
+        }): any;
+        creditCard(): any;
+        ip(): any;
+        country(): any;
+        locale(): any;
+        jwt(): any;
+        slug(): any;
+        latlng(): any;
+        postalCode(locale?: string): any;
+        password(options?: {
+            minLength?: number;
+            minNumbers?: number;
+            minSymbols?: number;
+            minLowercase?: number;
+            minUppercase?: number;
+        }): any;
+        url(options?: {
+            require_protocol?: boolean;
+            require_valid_protocol?: boolean;
+            require_host?: boolean;
+            require_port?: boolean;
+            allow_protocol_relative_urls?: boolean;
+            allow_fragments?: boolean;
+            allow_query_components?: boolean;
+            validate_length?: boolean;
+            protocols?: string[];
+        }): any;
+        domain(options?: {
+            require_tld?: boolean;
+            allow_underscores?: boolean;
+            allow_trailing_dot?: boolean;
+            allow_numeric_tld?: boolean;
+            allow_wildcard?: boolean;
+            ignore_max_length?: boolean;
+        }): any;
+        uuid(version?: 2 | 1 | 5 | 3 | 4): any;
+        btc(): any;
+        eth(): any;
+        swift(): any;
+        mongo(): any;
+        format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+        toString(): any;
+        assertions: any[];
+        meta: {};
+        required(): any;
+        default(value: any): any;
+        custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+        strip(strip: any): any;
+        allow(...set: any[]): any;
+        reject(...set: any[]): any;
+        message(message: any): any;
+        tag(tags: any): any;
+        description(description: any): any;
+        options(options: any): any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): any;
+        append(schema: any): any;
+        toOpenApi(extra: any): any;
+        assertEnum(set: any, allow: any): any;
+        assert(type: any, fn: any): any;
+        pushAssertion(assertion: any): void;
+        transform(fn: any): any;
+        getSortIndex(type: any): number;
+        runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+        enumToOpenApi(): {
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            enum: any;
+            oneOf?: undefined;
+        } | {
+            oneOf: any[];
+            type?: undefined;
+            enum?: undefined;
+        };
+    };
+    include: {
+        min(length: number): any;
+        max(length: number): any;
+        trim(): any;
+        lowercase(assert?: boolean): any;
+        uppercase(assert?: boolean): any;
+        match(reg: RegExp): any;
+        email(): any;
+        phone(): any;
+        hex(): any;
+        md5(): any;
+        sha1(): any;
+        ascii(): any;
+        base64(options?: {
+            urlSafe?: boolean;
+        }): any;
+        creditCard(): any;
+        ip(): any;
+        country(): any;
+        locale(): any;
+        jwt(): any;
+        slug(): any;
+        latlng(): any;
+        postalCode(locale?: string): any;
+        password(options?: {
+            minLength?: number;
+            minNumbers?: number;
+            minSymbols?: number;
+            minLowercase?: number;
+            minUppercase?: number;
+        }): any;
+        url(options?: {
+            require_protocol?: boolean;
+            require_valid_protocol?: boolean;
+            require_host?: boolean;
+            require_port?: boolean;
+            allow_protocol_relative_urls?: boolean;
+            allow_fragments?: boolean;
+            allow_query_components?: boolean;
+            validate_length?: boolean;
+            protocols?: string[];
+        }): any;
+        domain(options?: {
+            require_tld?: boolean;
+            allow_underscores?: boolean;
+            allow_trailing_dot?: boolean;
+            allow_numeric_tld?: boolean;
+            allow_wildcard?: boolean;
+            ignore_max_length?: boolean;
+        }): any;
+        uuid(version?: 2 | 1 | 5 | 3 | 4): any;
+        btc(): any;
+        eth(): any;
+        swift(): any;
+        mongo(): any;
+        format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+        toString(): any;
+        assertions: any[];
+        meta: {};
+        required(): any;
+        default(value: any): any;
+        custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+        strip(strip: any): any;
+        allow(...set: any[]): any;
+        reject(...set: any[]): any;
+        message(message: any): any;
+        tag(tags: any): any;
+        description(description: any): any;
+        options(options: any): any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): any;
+        append(schema: any): any;
+        toOpenApi(extra: any): any;
+        assertEnum(set: any, allow: any): any;
+        assert(type: any, fn: any): any;
+        pushAssertion(assertion: any): void;
+        transform(fn: any): any;
+        getSortIndex(type: any): number;
+        runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+        enumToOpenApi(): {
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            enum: any;
+            oneOf?: undefined;
+        } | {
+            oneOf: any[];
+            type?: undefined;
+            enum?: undefined;
+        };
+    };
+    skip: {
+        min(min: number, message?: string): any;
+        max(max: number, message?: string): any;
+        negative(): any;
+        positive(): any;
+        integer(): any;
+        multiple(multiple: any): any;
+        format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+        toString(): any;
+        assertions: any[];
+        meta: {};
+        required(): any;
+        default(value: any): any;
+        custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+        strip(strip: any): any;
+        allow(...set: any[]): any;
+        reject(...set: any[]): any;
+        message(message: any): any;
+        tag(tags: any): any;
+        description(description: any): any;
+        options(options: any): any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): any;
+        append(schema: any): any;
+        toOpenApi(extra: any): any;
+        assertEnum(set: any, allow: any): any;
+        assert(type: any, fn: any): any;
+        pushAssertion(assertion: any): void;
+        transform(fn: any): any;
+        getSortIndex(type: any): number;
+        runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+        enumToOpenApi(): {
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            enum: any;
+            oneOf?: undefined;
+        } | {
+            oneOf: any[];
+            type?: undefined;
+            enum?: undefined;
+        };
+    };
+    sort: import("@bedrockio/yada/types/Schema").default;
+    limit: {
+        min(min: number, message?: string): any;
+        max(max: number, message?: string): any;
+        negative(): any;
+        positive(): any;
+        integer(): any;
+        multiple(multiple: any): any;
+        format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+        toString(): any;
+        assertions: any[];
+        meta: {};
+        required(): any;
+        default(value: any): any;
+        custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+        strip(strip: any): any;
+        allow(...set: any[]): any;
+        reject(...set: any[]): any;
+        message(message: any): any;
+        tag(tags: any): any;
+        description(description: any): any;
+        options(options: any): any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): any;
+        append(schema: any): any;
+        toOpenApi(extra: any): any;
+        assertEnum(set: any, allow: any): any;
+        assert(type: any, fn: any): any;
+        pushAssertion(assertion: any): void;
+        transform(fn: any): any;
+        getSortIndex(type: any): number;
+        runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+        enumToOpenApi(): {
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            enum: any;
+            oneOf?: undefined;
+        } | {
+            oneOf: any[];
+            type?: undefined;
+            enum?: undefined;
+        };
+    };
+};
+//# sourceMappingURL=search.d.ts.map

package/types/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAmBA,gEAyDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBC"}

package/types/serialization.d.ts

@@ -0,0 +1,6 @@
+export namespace serializeOptions {
+    const getters: boolean;
+    const versionKey: boolean;
+    function transform(doc: any, ret: any, options: any): void;
+}
+//# sourceMappingURL=serialization.d.ts.map

package/types/serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.js"],"names":[],"mappings":";;;IASa,2DAIV"}

package/types/slug.d.ts

@@ -0,0 +1,2 @@
+export function applySlug(schema: any): void;
+//# sourceMappingURL=slug.d.ts.map

package/types/slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../src/slug.js"],"names":[],"mappings":"AAIA,6CAsBC"}

package/types/soft-delete.d.ts

@@ -0,0 +1,4 @@
+export function applySoftDelete(schema: any): void;
+export function assertUnique(obj: any, options: any): Promise<void>;
+export function hasUniqueConstraints(schema: any): boolean;
+//# sourceMappingURL=soft-delete.d.ts.map

package/types/soft-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAAA,mDAGC;AA4PD,oEAsBC;AAgDD,2DAKC"}

package/types/testing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Helper to quickly create models for testing.
+ * Accepts a definition's `attributes` object and
+ * an optional model name as the first argument.
+ * [Link](https://github.com/bedrockio/model#testing)
+ * @returns mongoose.Model
+ */
+export function createTestModel(...args: any[]): mongoose.Model<any, unknown, unknown, unknown, any>;
+export function getTestModelName(): string;
+import mongoose from "mongoose";
+//# sourceMappingURL=testing.d.ts.map

package/types/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,qGAiBC;AAED,2CAEC"}

package/types/utils.d.ts

@@ -0,0 +1,8 @@
+export function isMongooseSchema(obj: any): boolean;
+export function isReferenceField(obj: any, path: any): boolean;
+export function isDateField(obj: any, path: any): boolean;
+export function isNumberField(obj: any, path: any): boolean;
+export function isSchemaTypedef(arg: any): boolean;
+export function resolveField(obj: any, path: any): any;
+export function resolveInnerField(obj: any, path: any): any;
+//# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAEA,oDAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAOD,mDAGC;AAKD,uDAMC;AAID,4DAMC"}

package/types/validation.d.ts

@@ -0,0 +1,13 @@
+export function addValidators(schemas: any): void;
+export function applyValidation(schema: any, definition: any): void;
+export function getValidationSchema(attributes: any, options?: {}): any;
+export function getNamedValidator(name: any): {
+    (val: any): Promise<void>;
+    schema: any;
+};
+export function getTupleValidator(types: any): {
+    (val: any): Promise<void>;
+    schema: any;
+};
+export const OBJECT_ID_SCHEMA: import("@bedrockio/yada/types/Schema").default;
+//# sourceMappingURL=validation.d.ts.map

package/types/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiEA,kDAEC;AAED,oEA0DC;AAaD,wEAeC;AAyND;;;EAEC;AAED;;;EAKC;AAtWD,8EAUK"}

package/types/warn.d.ts

@@ -0,0 +1,2 @@
+export default function warn(...lines: any[]): void;
+//# sourceMappingURL=warn.d.ts.map

package/types/warn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../src/warn.js"],"names":[],"mappings":"AAEA,oDAIC"}

package/babel.config.cjs

@@ -1,41 +0,0 @@
-const path = require('path');
-
-const { BUILD_DIR } = process.env;
-
-module.exports = {
-  presets: [
-    [
-      '@babel/preset-env',
-      {
-        targets: {
-          node: 'current',
-        },
-      },
-    ],
-  ],
-  plugins: [
-    'lodash',
-    ...(BUILD_DIR
-      ? [
-          [
-            'import-replacement',
-            {
-              rules: [
-                {
-                  match: 'mongoose',
-                  replacement: path.resolve(BUILD_DIR, 'node_modules/mongoose'),
-                },
-                {
-                  match: '@bedrockio/yada',
-                  replacement: path.resolve(
-                    BUILD_DIR,
-                    'node_modules/@bedrockio/yada'
-                  ),
-                },
-              ],
-            },
-          ],
-        ]
-      : []),
-  ],
-};

package/jest.config.js

@@ -1,8 +0,0 @@
-process.env.ENV_NAME = 'test';
-
-export default {
-  preset: '@shelf/jest-mongodb',
-  setupFilesAfterEnv: ['<rootDir>/test/setup'],
-  // https://github.com/shelfio/jest-mongodb#6-jest-watch-mode-gotcha
-  watchPathIgnorePatterns: ['globalConfig'],
-};

package/test/assign.test.js

@@ -1,225 +0,0 @@
-import mongoose from 'mongoose';
-
-import { createTestModel } from '../src/testing';
-
-describe('assign', () => {
-  it('should allow assignment of fields', async () => {
-    const User = createTestModel({
-      date: 'Date',
-      name: 'String',
-      number: 'Number',
-    });
-    const user = new User();
-    const now = Date.now();
-    user.assign({
-      name: 'fake name',
-      number: 5,
-      date: new Date(now),
-    });
-    expect(user.name).toBe('fake name');
-    expect(user.number).toBe(5);
-    expect(user.date.getTime()).toBe(now);
-  });
-
-  it('should delete falsy values for reference fields', async () => {
-    const User = createTestModel();
-    const Shop = createTestModel({
-      user: {
-        ref: User.modelName,
-        type: mongoose.Schema.Types.ObjectId,
-      },
-      nested: {
-        name: 'String',
-        user: {
-          ref: User.modelName,
-          type: mongoose.Schema.Types.ObjectId,
-        },
-      },
-    });
-    const id = mongoose.Types.ObjectId().toString();
-    const shop = new Shop({
-      user: id,
-      nested: {
-        name: 'fake',
-        user: id,
-      },
-    });
-    await shop.save();
-
-    let data = JSON.parse(JSON.stringify(shop));
-    expect(data).toMatchObject({
-      user: id,
-      nested: {
-        name: 'fake',
-        user: id,
-      },
-    });
-    shop.assign({
-      user: '',
-      nested: {
-        user: '',
-      },
-    });
-    await shop.save();
-
-    data = JSON.parse(JSON.stringify(shop));
-    expect(data.user).toBeUndefined();
-    expect(data.nested).toEqual({
-      name: 'fake',
-    });
-  });
-
-  it('should still allow assignment of empty arrays for multi-reference fields', async () => {
-    const User = createTestModel();
-    const Shop = createTestModel({
-      users: [
-        {
-          ref: User.modelName,
-          type: mongoose.Schema.Types.ObjectId,
-        },
-      ],
-    });
-    const shop = new Shop({
-      users: ['5f63b1b88f09266f237e9d29', '5f63b1b88f09266f237e9d29'],
-    });
-    await shop.save();
-
-    let data = JSON.parse(JSON.stringify(shop));
-    expect(data.users).toEqual([
-      '5f63b1b88f09266f237e9d29',
-      '5f63b1b88f09266f237e9d29',
-    ]);
-    shop.assign({
-      users: [],
-    });
-    await shop.save();
-    data = JSON.parse(JSON.stringify(shop));
-    expect(data.users).toEqual([]);
-  });
-
-  it('should allow partial assignment of nested fields', async () => {
-    const User = createTestModel({
-      profile: {
-        firstName: 'String',
-        lastName: 'String',
-      },
-    });
-
-    const user = await User.create({
-      profile: {
-        firstName: 'John',
-        lastName: 'Doe',
-      },
-    });
-
-    user.assign({
-      profile: {
-        firstName: 'Jane',
-      },
-    });
-    await user.save();
-
-    expect(user.profile.firstName).toEqual('Jane');
-    expect(user.profile.lastName).toEqual('Doe');
-  });
-
-  it('should naively set nested array fields', async () => {
-    const Shop = createTestModel({
-      products: [
-        {
-          name: 'String',
-        },
-      ],
-    });
-    const shop = await Shop.create({
-      products: [
-        {
-          name: 'shampoo',
-        },
-      ],
-    });
-
-    shop.assign({
-      products: [
-        {
-          name: 'conditioner',
-        },
-        {
-          name: 'body wash',
-        },
-      ],
-    });
-    await shop.save();
-
-    expect(shop.products[0].name).toBe('conditioner');
-    expect(shop.products[1].name).toBe('body wash');
-  });
-
-  it('should not overwrite mixed content fields', async () => {
-    const User = createTestModel({
-      profile: 'Object',
-    });
-
-    const user = await User.create({
-      profile: {
-        foo: 'foo',
-      },
-    });
-
-    user.assign({
-      profile: {
-        bar: 'bar',
-      },
-    });
-    await user.save();
-
-    expect(user.profile).toEqual({
-      foo: 'foo',
-      bar: 'bar',
-    });
-  });
-
-  it('should delete mixed content fields with null', async () => {
-    const User = createTestModel({
-      profile: 'Object',
-    });
-
-    let user = await User.create({
-      profile: {
-        name: 'Bob',
-        age: 30,
-      },
-    });
-
-    user.assign({
-      profile: {
-        age: null,
-      },
-    });
-    await user.save();
-
-    user = await User.findById(user.id);
-
-    expect(user.profile.name).toBe('Bob');
-    expect('age' in user.profile).toBe(false);
-  });
-
-  it('should allow 0 to be set on number fields', async () => {
-    const User = createTestModel({
-      age: 'Number',
-    });
-
-    let user = await User.create({
-      age: 30,
-    });
-
-    user.assign({
-      age: 0,
-    });
-    await user.save();
-
-    user = await User.findById(user.id);
-
-    expect(user.age).toBe(0);
-  });
-});

package/test/definitions/custom-model.json

@@ -1,9 +0,0 @@
-{
-  "attributes": {
-    "name": {
-      "type": "String",
-      "trim": true,
-      "required": true
-    }
-  }
-}

package/test/definitions/special-category.json

@@ -1,18 +0,0 @@
-{
-  "attributes": {
-    "name": {
-      "type": "String",
-      "trim": true,
-      "required": true
-    },
-    "count": {
-      "type": "Number",
-      "required": true
-    },
-    "someRef": {
-      "type": "ObjectId",
-      "ref": "User",
-      "required": true
-    }
-  }
-}