cormo-graphql 1.4.0 → 2.0.0

package/eslint.config.mjs

@@ -0,0 +1,42 @@
+import baseConfig from '@croquiscom/eslint-config/requiring-type-checking.mjs';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  ...baseConfig,
+  {
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+
+    settings: {
+      'import/resolver': {
+        typescript: true,
+      },
+    },
+
+    rules: {
+      '@typescript-eslint/no-unsafe-call': 'off',
+      '@typescript-eslint/no-unsafe-member-access': 'off',
+      '@typescript-eslint/no-unsafe-assignment': 'off',
+      '@typescript-eslint/no-unsafe-return': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-floating-promises': 'off',
+      '@typescript-eslint/restrict-template-expressions': 'off',
+      '@typescript-eslint/restrict-plus-operands': 'off',
+      '@typescript-eslint/ban-types': 'off',
+      '@typescript-eslint/no-unsafe-argument': 'off',
+      '@typescript-eslint/consistent-indexed-object-style': 'off',
+    },
+  },
+  {
+    ignores: ['eslint.config.mjs', 'lib/**'],
+  },
+);

package/lib/{decorators.js → cjs/decorators.js}

@@ -23,7 +23,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Index = exports.BelongsTo = exports.HasOne = exports.HasMany = exports.ObjectColumn = exports.Column = exports.Model = void 0;
+exports.Model = Model;
+exports.Column = Column;
+exports.ObjectColumn = ObjectColumn;
+exports.HasMany = HasMany;
+exports.HasOne = HasOne;
+exports.BelongsTo = BelongsTo;
+exports.Index = Index;
 const cormo = __importStar(require("cormo"));
 function Model(options = {}) {
     const c = cormo.Model({ connection: options.connection, name: options.name, description: options.description });
@@ -31,7 +37,6 @@ function Model(options = {}) {
         c(ctor);
     };
 }
-exports.Model = Model;
 function Column(options) {
     let cormo_type;
     if (options.enum) {
@@ -52,14 +57,12 @@ function Column(options) {
         c(target, propertyKey);
     };
 }
-exports.Column = Column;
 function ObjectColumn(options) {
     const c = cormo.ObjectColumn(options.type);
     return (target, propertyKey) => {
         c(target, propertyKey);
     };
 }
-exports.ObjectColumn = ObjectColumn;
 function HasMany(options) {
     const c_options = {
         foreign_key: options.foreign_key,
@@ -71,7 +74,6 @@ function HasMany(options) {
         c(target, propertyKey);
     };
 }
-exports.HasMany = HasMany;
 function HasOne(options) {
     const c_options = {
         foreign_key: options.foreign_key,
@@ -83,7 +85,6 @@ function HasOne(options) {
         c(target, propertyKey);
     };
 }
-exports.HasOne = HasOne;
 function BelongsTo(options) {
     const c_options = {
         foreign_key: options.foreign_key,
@@ -95,11 +96,9 @@ function BelongsTo(options) {
         c(target, propertyKey);
     };
 }
-exports.BelongsTo = BelongsTo;
 function Index(columns, options) {
     const c = cormo.Index(columns, options);
     return (ctor) => {
         c(ctor);
     };
 }
-exports.Index = Index;

package/lib/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorators.js';
+export * from './schema.js';

package/lib/{index.js → cjs/index.js}

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./decorators"), exports);
-__exportStar(require("./schema"), exports);
+__exportStar(require("./decorators.js"), exports);
+__exportStar(require("./schema.js"), exports);

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/{schema.js → cjs/schema.js}

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefaultCrudSchema = void 0;
+exports.createDefaultCrudSchema = createDefaultCrudSchema;
 const crary_graphql_1 = require("@croquiscom/crary-graphql");
 const cormo = __importStar(require("cormo"));
 const graphql_1 = require("graphql");
@@ -385,4 +385,3 @@ function createDefaultCrudSchema(model_class, options = {}) {
         }),
     });
 }
-exports.createDefaultCrudSchema = createDefaultCrudSchema;

package/lib/cjs/tsconfig.build.cjs.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/decorators.ts","../../src/index.ts","../../src/schema.ts"],"version":"5.6.3"}

package/lib/esm/decorators.d.ts

@@ -0,0 +1,53 @@
+import * as cormo from 'cormo';
+export declare function Model(options?: {
+    connection?: cormo.Connection;
+    name?: string;
+    description?: string;
+}): (ctor: typeof cormo.BaseModel) => void;
+interface ColumnBasicOptions {
+    required?: boolean;
+    graphql_required?: boolean;
+    unique?: boolean;
+    name?: string;
+    description?: string;
+    default_value?: string | number | (() => string | number);
+}
+export declare function Column(options: ({
+    enum: any;
+} & ColumnBasicOptions) | ({
+    type: cormo.types.ColumnType | cormo.types.ColumnType[];
+} & ColumnBasicOptions)): PropertyDecorator;
+interface ObjectColumnOptions {
+    type: any;
+    required?: boolean;
+    description?: string;
+}
+export declare function ObjectColumn(options: ObjectColumnOptions): PropertyDecorator;
+interface HasManyBasicOptions {
+    type?: string;
+    foreign_key?: string;
+    integrity?: 'ignore' | 'nullify' | 'restrict' | 'delete';
+    description?: string;
+}
+export declare function HasMany(options: HasManyBasicOptions): (target: cormo.BaseModel, propertyKey: string) => void;
+interface HasOneBasicOptions {
+    type?: string;
+    foreign_key?: string;
+    integrity?: 'ignore' | 'nullify' | 'restrict' | 'delete';
+    description?: string;
+}
+export declare function HasOne(options: HasOneBasicOptions): (target: cormo.BaseModel, propertyKey: string) => void;
+interface BelongsToBasicOptions {
+    type?: string;
+    required?: boolean;
+    foreign_key?: string;
+    description?: string;
+}
+export declare function BelongsTo(options: BelongsToBasicOptions): (target: cormo.BaseModel, propertyKey: string) => void;
+export declare function Index(columns: {
+    [column: string]: 1 | -1;
+}, options?: {
+    name?: string;
+    unique?: boolean;
+}): (ctor: typeof cormo.BaseModel) => void;
+export {};

package/lib/esm/decorators.js

@@ -0,0 +1,72 @@
+import * as cormo from 'cormo';
+export function Model(options = {}) {
+    const c = cormo.Model({ connection: options.connection, name: options.name, description: options.description });
+    return (ctor) => {
+        c(ctor);
+    };
+}
+export function Column(options) {
+    let cormo_type;
+    if (options.enum) {
+        cormo_type = cormo.types.Integer;
+    }
+    else {
+        cormo_type = options.type;
+    }
+    const c = cormo.Column({
+        default_value: options.default_value,
+        name: options.name,
+        required: options.required,
+        type: cormo_type,
+        description: options.description,
+        unique: options.unique,
+    });
+    return (target, propertyKey) => {
+        c(target, propertyKey);
+    };
+}
+export function ObjectColumn(options) {
+    const c = cormo.ObjectColumn(options.type);
+    return (target, propertyKey) => {
+        c(target, propertyKey);
+    };
+}
+export function HasMany(options) {
+    const c_options = {
+        foreign_key: options.foreign_key,
+        integrity: options.integrity,
+        type: options.type,
+    };
+    const c = cormo.HasMany(c_options);
+    return (target, propertyKey) => {
+        c(target, propertyKey);
+    };
+}
+export function HasOne(options) {
+    const c_options = {
+        foreign_key: options.foreign_key,
+        integrity: options.integrity,
+        type: options.type,
+    };
+    const c = cormo.HasOne(c_options);
+    return (target, propertyKey) => {
+        c(target, propertyKey);
+    };
+}
+export function BelongsTo(options) {
+    const c_options = {
+        foreign_key: options.foreign_key,
+        required: options.required,
+        type: options.type,
+    };
+    const c = cormo.BelongsTo(c_options);
+    return (target, propertyKey) => {
+        c(target, propertyKey);
+    };
+}
+export function Index(columns, options) {
+    const c = cormo.Index(columns, options);
+    return (ctor) => {
+        c(ctor);
+    };
+}

package/lib/esm/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorators.js';
+export * from './schema.js';

package/lib/esm/index.js

@@ -0,0 +1,2 @@
+export * from './decorators.js';
+export * from './schema.js';

package/lib/esm/schema.d.ts

@@ -0,0 +1,11 @@
+import * as cormo from 'cormo';
+import { GraphQLSchema } from 'graphql';
+interface Options {
+    id_description?: string;
+    list_type_description?: string;
+    item_list_description?: string;
+    created_at_column?: string;
+    updated_at_column?: string;
+}
+export declare function createDefaultCrudSchema(model_class: typeof cormo.BaseModel, options?: Options): GraphQLSchema;
+export {};

package/lib/esm/schema.js

@@ -0,0 +1,358 @@
+import { CrJson, CrTimestamp, getFieldList } from '@croquiscom/crary-graphql';
+import * as cormo from 'cormo';
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLString, } from 'graphql';
+import _ from 'lodash';
+function getGraphQlType(property) {
+    let graphql_type;
+    if (property.record_id) {
+        return new GraphQLNonNull(GraphQLID);
+    }
+    else if (property.type_class === cormo.types.Number) {
+        graphql_type = GraphQLFloat;
+    }
+    else if (property.type_class === cormo.types.Integer) {
+        graphql_type = GraphQLInt;
+    }
+    else if (property.type_class === cormo.types.String) {
+        graphql_type = GraphQLString;
+    }
+    else if (property.type_class === cormo.types.Text) {
+        graphql_type = GraphQLString;
+    }
+    else if (property.type_class === cormo.types.Date) {
+        graphql_type = CrTimestamp;
+    }
+    else if (property.type_class === cormo.types.Object) {
+        graphql_type = CrJson;
+    }
+    if (graphql_type && property.required) {
+        return new GraphQLNonNull(graphql_type);
+    }
+    return graphql_type;
+}
+function createSingleType(model_class, options) {
+    const fields = {};
+    for (const [column, property] of Object.entries(model_class._schema)) {
+        if (!property) {
+            continue;
+        }
+        const graphql_type = getGraphQlType(property);
+        if (graphql_type) {
+            const description = column === 'id' ? options.id_description : property.description;
+            fields[column] = {
+                description,
+                type: graphql_type,
+            };
+        }
+    }
+    return new GraphQLObjectType({
+        description: model_class.description,
+        fields,
+        name: model_class.name,
+    });
+}
+function createListType(model_class, options, single_type) {
+    return new GraphQLObjectType({
+        description: options.list_type_description,
+        fields: {
+            item_list: {
+                description: options.item_list_description,
+                async resolve(source, args, context, info) {
+                    args = source.__args;
+                    const query = model_class.query();
+                    for (const [field, value] of Object.entries(args)) {
+                        if (value) {
+                            if (field.endsWith('_list')) {
+                                query.where({ [field.replace(/_list$/, '')]: value });
+                            }
+                            else if (field.endsWith('_istartswith')) {
+                                query.where({ [field.replace(/_istartswith$/, '')]: { $startswith: value } });
+                            }
+                            else if (field.endsWith('_icontains')) {
+                                query.where({ [field.replace(/_icontains$/, '')]: { $contains: value } });
+                            }
+                            else if (field.endsWith('_gte')) {
+                                query.where({ [field.replace(/_gte$/, '')]: { $gte: value } });
+                            }
+                            else if (field.endsWith('_gt')) {
+                                query.where({ [field.replace(/_gt$/, '')]: { $gt: value } });
+                            }
+                            else if (field.endsWith('_lte')) {
+                                query.where({ [field.replace(/_lte$/, '')]: { $lte: value } });
+                            }
+                            else if (field.endsWith('_lt')) {
+                                query.where({ [field.replace(/_lt$/, '')]: { $lt: value } });
+                            }
+                            else if (field === 'order') {
+                                query.order(value);
+                            }
+                            else if (field === 'limit_count') {
+                                query.limit(value);
+                            }
+                            else if (field === 'skip_count') {
+                                query.skip(value);
+                            }
+                            else {
+                                query.where({ [field]: value });
+                            }
+                        }
+                    }
+                    return await query.select(getFieldList(info));
+                },
+                type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(single_type))),
+            },
+        },
+        name: model_class.name + 'List',
+    });
+}
+function createCreateInputType(model_class, options) {
+    const fields = {};
+    for (const [column, property] of Object.entries(model_class._schema)) {
+        if (!property) {
+            continue;
+        }
+        if (column === 'id') {
+            continue;
+        }
+        if (column === options.created_at_column) {
+            continue;
+        }
+        if (column === options.updated_at_column) {
+            continue;
+        }
+        const graphql_type = getGraphQlType(property);
+        if (graphql_type) {
+            const description = column === 'id' ? options.id_description : property.description;
+            fields[column] = {
+                description,
+                type: graphql_type,
+            };
+        }
+    }
+    return new GraphQLInputObjectType({
+        fields,
+        name: `Create${model_class.name}Input`,
+    });
+}
+function createUpdateInputType(model_class, options) {
+    const fields = {};
+    for (const [column, property] of Object.entries(model_class._schema)) {
+        if (!property) {
+            continue;
+        }
+        if (column === options.created_at_column) {
+            continue;
+        }
+        if (column === options.updated_at_column) {
+            continue;
+        }
+        const graphql_type = getGraphQlType(property);
+        if (graphql_type) {
+            const description = column === 'id' ? options.id_description : property.description;
+            fields[column] = {
+                description,
+                type: graphql_type,
+            };
+        }
+    }
+    return new GraphQLInputObjectType({
+        fields,
+        name: `Update${model_class.name}Input`,
+    });
+}
+function createDeleteInputType(model_class, options) {
+    const fields = {};
+    fields.id = {
+        description: options.id_description,
+        type: new GraphQLNonNull(GraphQLID),
+    };
+    return new GraphQLInputObjectType({
+        fields,
+        name: `Delete${model_class.name}Input`,
+    });
+}
+function createOrderType(model_class, _options) {
+    const values = {};
+    for (const [column, property] of Object.entries(model_class._schema)) {
+        if (!property) {
+            continue;
+        }
+        if (column === 'id' ||
+            property.type_class === cormo.types.String ||
+            property.type_class === cormo.types.Integer ||
+            property.type_class === cormo.types.BigInteger) {
+            values[column.toUpperCase() + '_ASC'] = {
+                value: column,
+            };
+            values[column.toUpperCase() + '_DESC'] = {
+                value: '-' + column,
+            };
+        }
+    }
+    return new GraphQLEnumType({
+        name: `${model_class.name}OrderType`,
+        values,
+    });
+}
+function buildListQueryArgs(model_class, options) {
+    const list_query_args = {};
+    for (const [column, property] of Object.entries(model_class._schema)) {
+        if (!property) {
+            continue;
+        }
+        if (column === 'id') {
+            list_query_args[column + '_list'] = {
+                type: new GraphQLList(new GraphQLNonNull(GraphQLID)),
+            };
+        }
+        else if (property.record_id) {
+            list_query_args[column] = {
+                type: GraphQLID,
+            };
+        }
+        else if (property.type_class === cormo.types.String || property.type_class === cormo.types.Text) {
+            list_query_args[column] = {
+                type: GraphQLString,
+            };
+            list_query_args[column + '_istartswith'] = {
+                type: GraphQLString,
+            };
+            list_query_args[column + '_icontains'] = {
+                type: GraphQLString,
+            };
+        }
+        else if (property.type_class === cormo.types.Integer) {
+            list_query_args[column] = {
+                type: GraphQLInt,
+            };
+            list_query_args[column + '_gte'] = {
+                type: GraphQLInt,
+            };
+            list_query_args[column + '_gt'] = {
+                type: GraphQLInt,
+            };
+            list_query_args[column + '_lte'] = {
+                type: GraphQLInt,
+            };
+            list_query_args[column + '_lt'] = {
+                type: GraphQLInt,
+            };
+        }
+    }
+    list_query_args.order = {
+        type: createOrderType(model_class, options),
+    };
+    list_query_args.limit_count = {
+        type: GraphQLInt,
+    };
+    list_query_args.skip_count = {
+        type: GraphQLInt,
+    };
+    return list_query_args;
+}
+export function createDefaultCrudSchema(model_class, options = {}) {
+    model_class._connection.applyAssociations();
+    const camel_name = model_class.name;
+    const snake_name = _.snakeCase(camel_name);
+    const single_type = createSingleType(model_class, options);
+    const list_type = createListType(model_class, options, single_type);
+    const single_query_args = {
+        id: {
+            type: GraphQLID,
+        },
+    };
+    const list_query_args = buildListQueryArgs(model_class, options);
+    const create_input_type = createCreateInputType(model_class, options);
+    const update_input_type = createUpdateInputType(model_class, options);
+    const delete_input_type = createDeleteInputType(model_class, options);
+    return new GraphQLSchema({
+        mutation: new GraphQLObjectType({
+            fields: {
+                [`create${camel_name}`]: {
+                    args: {
+                        input: {
+                            type: create_input_type,
+                        },
+                    },
+                    async resolve(source, args) {
+                        const data = args.input;
+                        const date = Date.now();
+                        if (options.created_at_column) {
+                            data[options.created_at_column] = date;
+                        }
+                        if (options.updated_at_column) {
+                            data[options.updated_at_column] = date;
+                        }
+                        return await model_class.create(data);
+                    },
+                    type: new GraphQLNonNull(single_type),
+                },
+                [`update${camel_name}`]: {
+                    args: {
+                        input: {
+                            type: update_input_type,
+                        },
+                    },
+                    async resolve(_source, args) {
+                        const data = args.input;
+                        const date = Date.now();
+                        if (options.updated_at_column) {
+                            data[options.updated_at_column] = date;
+                        }
+                        await model_class.find(args.input.id).update(data);
+                        return await model_class.find(args.input.id);
+                    },
+                    type: new GraphQLNonNull(single_type),
+                },
+                [`delete${camel_name}`]: {
+                    args: {
+                        input: {
+                            type: delete_input_type,
+                        },
+                    },
+                    async resolve(source, args) {
+                        const delete_count = await model_class.find(args.input.id).delete();
+                        if (delete_count === 0) {
+                            throw new Error('not found');
+                        }
+                        return true;
+                    },
+                    type: new GraphQLNonNull(GraphQLBoolean),
+                },
+            },
+            name: 'Mutation',
+        }),
+        query: new GraphQLObjectType({
+            fields: {
+                [snake_name]: {
+                    args: single_query_args,
+                    description: `Single query for ${camel_name}`,
+                    async resolve(source, args, context, info) {
+                        const query = model_class.query().one();
+                        let has_query = false;
+                        for (const [field, value] of Object.entries(args)) {
+                            if (value) {
+                                has_query = true;
+                                query.where({ [field]: value });
+                            }
+                        }
+                        if (!has_query) {
+                            return null;
+                        }
+                        return await query.select(getFieldList(info));
+                    },
+                    type: single_type,
+                },
+                [snake_name + '_list']: {
+                    args: list_query_args,
+                    description: `List query for ${camel_name}`,
+                    resolve(source, args) {
+                        return { __args: args };
+                    },
+                    type: new GraphQLNonNull(list_type),
+                },
+            },
+            name: 'Query',
+        }),
+    });
+}

package/lib/esm/tsconfig.build.esm.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/decorators.ts","../../src/index.ts","../../src/schema.ts"],"version":"5.6.3"}

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "cormo-graphql",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "GraphQL support for CORMO",
-  "main": "./lib",
-  "types": "./lib/index.d.ts",
+  "type": "module",
+  "main": "./lib/cjs/index.js",
+  "types": "./lib/cjs/index.d.ts",
+  "exports": {
+    "import": "./lib/esm/index.js",
+    "require": "./lib/cjs/index.js"
+  },
   "scripts": {
     "prepublishOnly": "npm run lint && npm run build",
-    "build": "rimraf lib && tsc -p src/tsconfig.build.json",
-    "lint": "../../node_modules/.bin/eslint --ext .js,.ts .",
+    "build": "rimraf lib && tsc -b src/tsconfig.build.cjs.json src/tsconfig.build.esm.json && echo '{\"type\":\"commonjs\"}' > lib/cjs/package.json",
+    "lint": "../../node_modules/.bin/eslint .",
     "test:type": "tsc --noEmit",
-    "test:unit": "NODE_ENV=test TZ=Etc/UTC mocha --require ts-node/register/transpile-only ./test/*/*.ts",
+    "test:unit": "NODE_ENV=test TZ=Etc/UTC mocha -n import=tsx ./test/*/*.ts",
     "test": "npm run test:type && npm run lint && npm run test:unit --",
     "test:debug": "npm run test:unit -- --inspect-brk=30000"
   },
@@ -25,24 +30,24 @@
   "homepage": "https://github.com/croquiscom/cormo",
   "dependencies": {
     "@croquiscom/crary-graphql": "^1.3.1",
-    "cormo": "^1.4.0",
-    "graphql": "^16.8.1",
+    "cormo": "^2.0.0",
+    "graphql": "^16.9.0",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
     "@types/chai": "^4.3.11",
-    "@types/lodash": "^4.17.5",
-    "@types/mocha": "^10.0.6",
-    "@types/node": "^20.14.2",
-    "@types/sinon": "^17.0.2",
+    "@types/lodash": "^4.17.12",
+    "@types/mocha": "^10.0.9",
+    "@types/node": "^22.8.1",
+    "@types/sinon": "^17.0.3",
     "chai": "^4.3.10",
-    "mocha": "^10.4.0",
+    "mocha": "^10.7.3",
     "mysql": "^2.18.1",
-    "mysql2": "^3.10.0",
-    "rimraf": "^5.0.7",
-    "sinon": "^17.0.1",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.4.5"
+    "mysql2": "^3.11.3",
+    "rimraf": "^6.0.1",
+    "sinon": "^19.0.2",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3"
   },
-  "gitHead": "f2986889533f2ee6c5f7969ff89dda3575bd1a54"
+  "gitHead": "c857e9bed767d8d84633f266c2f153a88fb380ec"
 }

package/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "compilerOptions": {
-    "target": "es2017",
-    "module": "commonjs",
+    "target": "es2021",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "declaration": true,
     "experimentalDecorators": true,
     "strict": true,

package/.eslintrc.js

@@ -1,24 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    node: true,
-  },
-  extends: ['@croquiscom/eslint-config/requiring-type-checking'],
-  parserOptions: {
-    project: [`${__dirname}/tsconfig.json`],
-  },
-  ignorePatterns: ['.eslintrc.js', 'lib/'],
-  rules: {
-    '@typescript-eslint/no-unsafe-call': 'off',
-    '@typescript-eslint/no-unsafe-member-access': 'off',
-    '@typescript-eslint/no-unsafe-assignment': 'off',
-    '@typescript-eslint/no-unsafe-return': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-floating-promises': 'off',
-    '@typescript-eslint/restrict-template-expressions': 'off',
-    '@typescript-eslint/restrict-plus-operands': 'off',
-    '@typescript-eslint/ban-types': 'off',
-    '@typescript-eslint/no-unsafe-argument': 'off',
-    '@typescript-eslint/consistent-indexed-object-style': 'off',
-  },
-};

package/lib/index.d.ts

@@ -1,2 +0,0 @@
-export * from './decorators';
-export * from './schema';