typeorm-hasura 0.0.22 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-hasura",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "",
   "keywords": [
     "hasura",
@@ -46,7 +46,7 @@
     "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
     "graphql-tag": "^2.0.0",
     "hasura-metadata-types": "^2.22.1",
-    "lodash.snakecase": "^4.1.1"
+    "lodash-es": "^4.18.1"
   },
   "peerDependencies": {
     "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
@@ -56,7 +56,7 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",
-    "@types/lodash.snakecase": "^4.1.7",
+    "@types/lodash-es": "^4.17.12",
     "@types/node": "^18.14.0",
     "env-cmd": "^10.1.0",
     "jest": "^29.5.0",

package/src/builders/Metadata.ts

@@ -1,5 +1,4 @@
-import axios, { AxiosError } from "axios";
-import { DocumentNode } from "graphql";
+import type { DocumentNode } from "graphql";
 import type * as Hasura from "hasura-metadata-types";
 import { ActionBuildResult, DataSourceOptions, InheritedRoles } from "../types";
 import { generateSource } from "../mappers";
@@ -143,6 +142,7 @@ export class MetadataBuilder {
     */
     async applyMetadata({ hasuraUrl, adminSecret }: { hasuraUrl: string, adminSecret: string }) {
         const { metadata } = await this.getMetadata();
+        const { default: axios, AxiosError } = await import("axios");
         try {
             const { data } = await axios.post(`${hasuraUrl}/v1/metadata`, {
                 type: "replace_metadata",

package/src/mappers/graphql.ts

@@ -1,4 +1,4 @@
-import { DocumentNode, FieldDefinitionNode, InputValueDefinitionNode, TypeNode } from "graphql";
+import type { DocumentNode, FieldDefinitionNode, InputValueDefinitionNode, TypeNode } from "graphql";
 import type * as Hasura from "hasura-metadata-types";
 import { GraphQlMetadataForAction } from "../types";
 

package/src/mappers/operators.ts

@@ -1,4 +1,4 @@
-import { FindOperator } from "typeorm"
+import type { FindOperator } from "typeorm"
 import { ExclusiveParameters, Operators } from "../types"
 
 export function operatorMappers(operator: FindOperator<any>): ExclusiveParameters {

package/src/mappers/permissions.ts

@@ -1,4 +1,4 @@
-import * as TypeORM from "typeorm";
+import type { EntityMetadata } from "typeorm";
 import type * as Hasura from "hasura-metadata-types";
 import { ColumnMetadata, DataSourceOptions, EntityInternalStorageWorkspace, UserActionType } from "../types";
 import { convertWhereClause } from "./whereClause"
@@ -9,7 +9,7 @@ export type PermissionResult = Required<Pick<
 
 export function generatePermissions<Entity extends Object = Object>(
     dataSourceOptions: DataSourceOptions,
-    table: TypeORM.EntityMetadata,
+    table: EntityMetadata,
     { entityOptions, columnMetadata }: EntityInternalStorageWorkspace<Entity>,
 ): PermissionResult {
 

package/src/mappers/relationships.ts

@@ -1,4 +1,4 @@
-import * as TypeORM from "typeorm";
+import type { EntityMetadata } from "typeorm";
 import type * as Hasura from "hasura-metadata-types";
 
 type RelationshipKind = 'object_relationships' | 'array_relationships'
@@ -7,7 +7,7 @@ type Relationship =
     | Hasura.SameTableObjectRelationship
     | Hasura.ManualObjectRelationship
 
-export function generateRelationship(relation: TypeORM.EntityMetadata['relations'][number]): Relationship {
+export function generateRelationship(relation: EntityMetadata['relations'][number]): Relationship {
     const owningRelation = relation.isOwning ?
         relation : relation.inverseRelation;
 
@@ -62,7 +62,7 @@ export function generateRelationship(relation: TypeORM.EntityMetadata['relations
         throw new Error("Relation tableType is not available")
 }
 
-export function generateRelationships(relations: TypeORM.EntityMetadata['relations']):
+export function generateRelationships(relations: EntityMetadata['relations']):
     Pick<Hasura.MetadataTable, RelationshipKind> {
     const result: Required<Pick<Hasura.MetadataTable, RelationshipKind>> = {
         object_relationships: [],

package/src/mappers/table.ts

@@ -1,5 +1,5 @@
 import type * as Hasura from "hasura-metadata-types";
-import * as TypeORM from "typeorm";
+import type { EntityMetadata } from "typeorm";
 import { generateRelationships } from "./relationships";
 import { generateTableConfiguration } from "./tableConfiguration";
 import { DataSourceOptions } from "../types";
@@ -8,7 +8,7 @@ import { internalStorage } from "../internalStorage";
 
 export function generateTable<Entity extends Object>(
     dataSourceOptions: DataSourceOptions,
-    table: TypeORM.EntityMetadata
+    table: EntityMetadata
 ): Hasura.MetadataTable {
     const entityWorkspace = internalStorage.getEntityWorkspace<Entity>(table.target);
 

package/src/mappers/tableConfiguration.ts

@@ -1,10 +1,10 @@
-import * as TypeORM from "typeorm";
+import { EntityMetadata } from "typeorm";
 import type * as Hasura from "hasura-metadata-types";
 import { EntityInternalStorageWorkspace, EntityRootField } from "../types";
-import snakeCase from 'lodash.snakecase'
+import snakeCase from 'lodash-es/snakeCase'
 
 export function generateTableConfiguration<Entity extends Object>(
-    table: TypeORM.EntityMetadata,
+    table: EntityMetadata,
     { entityOptions, columnMetadata }: EntityInternalStorageWorkspace<Entity>,
 ): Hasura.MetadataTableConfig {
 

package/src/mappers/whereClause.ts

@@ -1,9 +1,10 @@
-import * as TypeORM from "typeorm";
+import { InstanceChecker } from "typeorm";
+import type { EntityMetadata, FindOptionsWhere } from "typeorm";
 import { Where, Filter, FilterAlt, ExclusiveParameters } from "../types";
 import { operatorMappers } from "./operators";
 
 export function convertWhereClause<Entity extends Object>(
-    table: TypeORM.EntityMetadata,
+    table: EntityMetadata,
     ...wheres: (Where<Entity> | undefined)[]
 ): Filter<Entity> {
     wheres = wheres.filter(Boolean)
@@ -20,8 +21,8 @@ export function convertWhereClause<Entity extends Object>(
 }
 
 function parseParameters<Entity extends Object>(
-    table: TypeORM.EntityMetadata,
-    where: TypeORM.FindOptionsWhere<Entity> | TypeORM.FindOptionsWhere<Entity>[]
+    table: EntityMetadata,
+    where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]
 ): Filter<Entity> {
     if (Array.isArray(where)) {
         return { _or: where.map(i => parseParameters(table, i)) }
@@ -35,7 +36,7 @@ function parseParameters<Entity extends Object>(
 
         const isJsonb = column?.type === "jsonb" && typeof parameterValue == "object"
 
-        if (TypeORM.InstanceChecker.isFindOperator(parameterValue) && !isJsonb) {
+        if (InstanceChecker.isFindOperator(parameterValue) && !isJsonb) {
             conditions.push({ [key]: operatorMappers(parameterValue) })
         } else if (
             typeof parameterValue === "string" ||
@@ -45,8 +46,8 @@ function parseParameters<Entity extends Object>(
             conditions.push({ [key]: { "_eq": parameterValue } })
         } else if (relation && parameterValue) {
             // this is a relation so we can parse it recursively
-            conditions.push({ [key]: parseParameters(relation.inverseEntityMetadata, parameterValue as TypeORM.FindOptionsWhere<Entity>) })
-        } else if (TypeORM.InstanceChecker.isFindOperator(parameterValue) && parameterValue.type == "not" && isJsonb) {
+            conditions.push({ [key]: parseParameters(relation.inverseEntityMetadata, parameterValue as FindOptionsWhere<Entity>) })
+        } else if (InstanceChecker.isFindOperator(parameterValue) && parameterValue.type == "not" && isJsonb) {
             conditions.push({ _not: { [key]: { "_contains": parameterValue.value } } })
         } else if (isJsonb) {
             conditions.push({ [key]: { "_contains": parameterValue } })

package/src/types/Action.ts

@@ -1,4 +1,4 @@
-import { DocumentNode } from "graphql"
+import type { DocumentNode } from "graphql"
 import type * as Hasura from "hasura-metadata-types";
 import { UserRoleName } from "./base";
 

package/src/types/DataSourceOptions.ts

@@ -1,9 +1,9 @@
-import * as TypeORM from "typeorm";
+import type { DataSource } from "typeorm";
 import type * as Hasura from "hasura-metadata-types";
 
 export interface DataSourceOptions {
     name: string;
-    dataSource: TypeORM.DataSource;
+    dataSource: DataSource;
     customizationNative?: Hasura.SourceCustomization;
 
     /**

package/src/types/whereClause.ts

@@ -1,4 +1,4 @@
-import { FindOptionsWhere, FindOperatorType, BaseEntity } from "typeorm";
+import type { FindOptionsWhere, FindOperatorType, BaseEntity } from "typeorm";
 
 export type Where<Entity> = FindOptionsWhere<Entity>[] | FindOptionsWhere<Entity>