typeorm-hasura 0.0.1

package/src/mappers/relationships.ts

@@ -0,0 +1,65 @@
+import * as TypeORM from "typeorm";
+import type * as Hasura from "hasura-metadata-types";
+
+type RelationshipKind = 'object_relationships' | 'array_relationships'
+
+export function generateRelationship(relation: TypeORM.EntityMetadata['relations'][number]): {
+    kind: RelationshipKind,
+    relationship: Hasura.LocalTableObjectRelationship | Hasura.SameTableObjectRelationship
+} {
+    const kind = relation.relationType.endsWith('-to-one') ? 'object_relationships' : 'array_relationships';
+
+    const owningRelation = relation.isOwning ? relation : relation.inverseRelation;
+
+    if (!owningRelation)
+        throw new Error('Does not support many-to-many relations yet, so we will skip this specific relation. ' +
+            'Also its possible that you have missed to set inverse side of the relation.');
+
+    const columns = owningRelation.joinColumns.map(column => column.propertyName);
+
+    // todo: does not work?
+    // const schema = owningRelation.entityMetadata.schema;
+    // @ts-ignore is that okay?
+    const schema = owningRelation.target.dataSource.options.schema || 'public';
+
+    const relationship: Hasura.LocalTableObjectRelationship | Hasura.SameTableObjectRelationship =
+        relation.isOwning ? {
+            name: relation.propertyName,
+            using: {
+                foreign_key_constraint_on: columns
+            }
+        } : {
+            name: relation.propertyName,
+            using: {
+                foreign_key_constraint_on: {
+                    columns,
+                    table: {
+                        name: owningRelation.entityMetadata.tableName,
+                        schema,
+                    }
+                }
+            }
+        }
+
+    return { kind, relationship };
+}
+
+export function generateRelationships(relations: TypeORM.EntityMetadata['relations']):
+    Pick<Hasura.MetadataTable, RelationshipKind> {
+    const result: Required<Pick<Hasura.MetadataTable, RelationshipKind>> = {
+        object_relationships: [],
+        array_relationships: [],
+    }
+
+    for (const relation of relations) {
+        try {
+            const { kind, relationship } = generateRelationship(relation);
+            // @ts-ignore dont want to play with types for now
+            result[kind].push(relationship);
+        } catch (e) {
+            console.warn(e);
+        }
+    }
+
+    return result;
+}

package/src/mappers/source.ts

@@ -0,0 +1,29 @@
+import type * as Hasura from "hasura-metadata-types";
+import { DataSourceOptions } from "../types";
+import { getHasuraKind } from "./hasuraKind";
+import { getDatabaseUrl } from "./databaseUrl";
+import { generateTable } from "./table";
+
+export function generateSource(dataSourceOptions: DataSourceOptions): Hasura.Source {
+    let { name, dataSource, customizationNative: customization } = dataSourceOptions;
+
+    // customization ??= {}
+    // customization.naming_convention ??= 'graphql-default'
+
+    return {
+        name,
+        kind: getHasuraKind(dataSource.options.type),
+        tables: [...dataSource.entityMetadatas]
+            .reverse()
+            .map(table => generateTable(dataSourceOptions, table)),
+        customization,
+        configuration: {
+            "connection_info": {
+                "database_url": getDatabaseUrl(dataSourceOptions),
+                "isolation_level": "read-committed",
+                "use_prepared_statements": false
+            },
+            "extensions_schema": "extensions_schema_test"
+        }
+    }
+}

package/src/mappers/table.ts

@@ -0,0 +1,27 @@
+import type * as Hasura from "hasura-metadata-types";
+import * as TypeORM from "typeorm";
+import { generateRelationships } from "./relationships";
+import { generateTableConfiguration } from "./tableConfiguration";
+import { DataSourceOptions } from "../types";
+import { generatePermissions } from "./permissions";
+import { internalStorage } from "../internalStorage";
+
+export function generateTable<Entity extends Object>(
+    dataSourceOptions: DataSourceOptions,
+    table: TypeORM.EntityMetadata
+): Hasura.MetadataTable {
+    const entityOptions = internalStorage.getEntityOptions<Entity>(table.target);
+    const columnMetadata = internalStorage.getEntityColumnsOptionsList(table.target);
+
+    return {
+        table: {
+            name: table.tableName,
+            // todo: does not work?
+            // schema: table.schema,
+            schema: 'schema' in table.connection.options && table.connection.options.schema || 'public',
+        },
+        configuration: generateTableConfiguration(table, entityOptions, columnMetadata),
+        ...generateRelationships(table.relations),
+        ...generatePermissions(dataSourceOptions, entityOptions, columnMetadata),
+    }
+}

package/src/mappers/tableConfiguration.ts

@@ -0,0 +1,45 @@
+import * as TypeORM from "typeorm";
+import type * as Hasura from "hasura-metadata-types";
+import { ColumnMetadata, EntityOptions, EntityRootField } from "../types";
+import snakeCase from 'lodash.snakecase'
+
+export function generateTableConfiguration<Entity extends Object>(table: TypeORM.EntityMetadata,
+    entityOptions: EntityOptions<Entity> | undefined,
+    columnMetadata: ColumnMetadata[]
+): Hasura.MetadataTableConfig {
+
+    let custom_name: string | undefined = entityOptions && entityOptions.customName || table.tableName;
+
+    const columnHasuraEntries: [string, Hasura.MetadataTableColumnConfig][] = [];
+    for (const column of columnMetadata) {
+        // looks like its only possible to set custom_name for columns here
+        if (column.options?.customName) {
+            columnHasuraEntries.push([column.propertyName, {
+                custom_name: column.options.customName,
+            }])
+        }
+    }
+    const column_config = columnHasuraEntries.length ? Object.fromEntries(columnHasuraEntries) : undefined;
+
+    const custom_root_fields: Record<string, EntityRootField> = {};
+    if (entityOptions?.customRootFields) {
+        // iterate over all possible root fields and push them to custom_root_fields
+        for (const rootField in entityOptions.customRootFields) {
+            let rootFieldConfig = entityOptions.customRootFields[rootField as keyof typeof entityOptions.customRootFields];
+            if (rootFieldConfig) {
+                if (typeof rootFieldConfig === 'string') {
+                    rootFieldConfig = {
+                        name: rootFieldConfig,
+                    };
+                }
+                custom_root_fields[snakeCase(rootField)] = rootFieldConfig;
+            }
+        }
+    }
+
+    return {
+        custom_name,
+        column_config,
+        custom_root_fields,
+    }
+}

package/src/mappers/whereClause.spec.ts

@@ -0,0 +1,85 @@
+import { Equal, Not, MoreThan, LessThan, MoreThanOrEqual, LessThanOrEqual, Like, ILike, In, BaseEntity } from "typeorm"
+
+import { convertWhereClause } from "./whereClause"
+import { User, Org, Product } from "../../dev-playground/entity";
+import { Where, Filter } from "../types";
+
+type Case<T extends BaseEntity> = {
+    input: Where<T>;
+    output: Filter<T>
+}
+
+const cases: Case<User>[] = [
+    {
+        input: {
+            id: "1",
+        },
+        output: {
+            id: { _eq: "1" }
+        }
+    },
+    {
+        input: {
+            id: "1",
+            name: "test"
+        },
+        output: {
+            _and: [
+                { id: { _eq: "1" } },
+                { name: { _eq: "test" } }
+            ]
+        }
+    },
+    {
+        input: [
+            { id: "1", name: "test" },
+            { id: "2", name: "test" }
+        ],
+        output: {
+            _or: [
+                { _and: [{ id: { _eq: "1" } }, { name: { _eq: "test" } }] },
+                { _and: [{ id: { _eq: "2" } }, { name: { _eq: "test" } }] }
+            ]
+        }
+    },
+    {
+        input: {
+            id: Not("1")
+        },
+        output: {
+            id: { _neq: "1" }
+        }
+    },
+    {
+        input: [
+            { id: Not("1"), name: "test" },
+            { id: "2", name: In(["test"]) }
+        ],
+        output: {
+            _or: [
+                { _and: [{ id: { _neq: "1" } }, { name: { _eq: "test" } }] },
+                { _and: [{ id: { _eq: "2" } }, { name: { _in: ["test"] } }] }
+
+            ],
+
+        },
+    },
+    {
+        input: {
+            products: {
+                id: "1"
+            }
+        },
+        output: {
+            products: {
+                id: { _eq: "1" },
+            }
+        }
+    }
+]
+
+describe("convert whereTypeorm to hasuraObj", () => {
+    cases.forEach(({ input, output }) =>
+        it("input to Equal output", () => expect(convertWhereClause(input)).toEqual(output))
+    )
+})

package/src/mappers/whereClause.ts

@@ -0,0 +1,41 @@
+import { FindOptionsWhere, InstanceChecker, And } from "typeorm";
+import { Where, Filter, Operators, } from "../types";
+
+export function convertWhereClause<Entity extends Object>(...wheres: (Where<Entity> | undefined)[]): Filter<Entity> {
+    wheres = wheres.filter(Boolean)
+    if (!wheres.length) return {}
+    if (wheres.length > 1) {
+        return {
+            _and: wheres.map(where => convertWhereClause(where))
+        }
+    }
+    const [where] = wheres
+
+    if (!where) return {}
+    if (Array.isArray(where)) {
+        return { _or: where.map(i => parseParameters(i)) }
+    }
+    return parseParameters(where)
+}
+
+function parseParameters<Entity extends Object>(object: FindOptionsWhere<Entity>): Filter<Entity> {
+    let conditions: Filter<Entity>[] = []
+    for (let key in object) {
+        const parameterValue = object[key]
+        if (InstanceChecker.isFindOperator(parameterValue)) {
+            const operator = Operators[parameterValue.type]
+            if (operator) {
+                conditions.push({ [key]: { [operator]: parameterValue.value } })
+            } else
+                throw new Error("this operator is not supported in this time");
+        } else if (["string", "number", "boolean"].includes(typeof parameterValue)) {
+            conditions.push({ [key]: { "_eq": parameterValue } })
+        } else if (typeof parameterValue === "object" && !Array.isArray(parameterValue) && parameterValue !== null) {
+            conditions.push({ [key]: parseParameters(parameterValue) })
+        } else
+            throw new Error("this parameter is not supported in this time");
+    }
+    return conditions.length == 0 ? {} :
+        conditions.length == 1 ? conditions[0] :
+            { _and: conditions }
+}

package/src/types/Action.ts

@@ -0,0 +1,27 @@
+import { DocumentNode } from "graphql"
+import type * as Hasura from "hasura-metadata-types";
+import { UserRoleName } from "./base";
+
+export type GraphQlMetadataForAction = {
+    baseActions: (Omit<Hasura.Action, 'definition'> & {
+        definition: Pick<Hasura.ActionDefinition, 'type' | 'output_type' | 'arguments'>;
+    })[],
+    custom_types: Hasura.CustomTypes,
+}
+
+export type ActionCustomMetadataV1 = {
+    comment?: string,
+    /**
+     * The action's webhook URL
+     */
+    handler: string,
+    definitionType: DocumentNode,
+    /**
+     * If set to true the client headers are forwarded to the webhook handler (default: false)
+     */
+    forwardClientHeaders?: boolean
+    nativeDefinition: Partial<Hasura.ActionDefinition>,
+    permissions?: { role: UserRoleName }[];
+}
+
+export type ActionBuildResult = Required<Pick<Hasura.Metadata['metadata'], 'actions' | 'custom_types'>>

package/src/types/Column.ts

@@ -0,0 +1,23 @@
+import { UserActionType, UserRoleName } from "./base";
+import { EntityTarget } from "./Entity";
+
+
+export interface ColumnOptions {
+    /**
+     * Column name which will be show up in hasura.
+     */
+    customName?: string;
+
+    /**
+     * Column type which will be allowed to do actions.
+     */
+    permissions?: {
+        [role: UserRoleName]: UserActionType[] | UserActionType | boolean
+    }
+}
+
+export interface ColumnMetadata {
+    object: EntityTarget,
+    propertyName: string,
+    options: ColumnOptions | undefined,
+}

package/src/types/DataSourceOptions.ts

@@ -0,0 +1,22 @@
+import * as TypeORM from "typeorm";
+import type * as Hasura from "hasura-metadata-types";
+
+export interface DataSourceOptions {
+    name: string;
+    dataSource: TypeORM.DataSource;
+    customizationNative?: Hasura.SourceCustomization;
+
+    /**
+     * override database url instead of url from data source
+     *
+     * @example `postgres://username:password@host:5432/database`
+     * @deprecated please rely on the `dataSource` parameter instead
+     */
+    databaseUrl?: string;
+
+    /**
+     * Set limit on number of rows fetched per request by default for all entities
+     * @default undefined
+     */
+    defaultSelectPermissionLimit?: number;
+}

package/src/types/Entity.ts

@@ -0,0 +1,53 @@
+import { UserActionType, UserRoleName } from "./base";
+import { BasePermissionRule, SelectPermissionRule } from "./permissions";
+import { Where } from "./whereClause";
+
+export type EntityTarget = any;
+
+export interface EntityRootField {
+    /**
+     * name for root field
+     */
+    name?: string;
+    /**
+     * user visible comment for root field
+     */
+    comment?: string;
+}
+
+export type Permissions<Entity extends Object> = {
+    [role: UserRoleName]: {
+        /**
+         * append where clause to all actions
+         */
+        where?: Where<Entity>;
+        select?: SelectPermissionRule<Entity> | boolean;
+    } & {
+        [action in Exclude<UserActionType, 'select'>]?: BasePermissionRule<Entity> | boolean;
+    }
+}
+
+export interface EntityOptions<Entity extends Object = Object> {
+    /**
+     * Table name which will be show up in hasura.
+     */
+    customName?: string;
+
+    customRootFields?: 
+        Partial<Record<
+            | 'select'
+            | 'selectByPk'
+            | 'selectAggregate'
+            | 'selectStream'
+            | 'insert'
+            | 'insertOne'
+            | 'update'
+            | 'updateByPk'
+            | 'delete'
+            | 'deleteByPk'
+            | 'updateMany'
+        , EntityRootField | string>>,
+
+    permissions?: Permissions<Entity>
+}
+

package/src/types/base.ts

@@ -0,0 +1,2 @@
+export type UserRoleName = string;
+export type UserActionType = 'select' | 'insert' | 'update' | 'delete';

package/src/types/index.ts

@@ -0,0 +1,7 @@
+export * from './Action'
+export * from './base'
+export * from './Column'
+export * from './DataSourceOptions'
+export * from './Entity'
+export * from './permissions'
+export * from './whereClause'

package/src/types/permissions.ts

@@ -0,0 +1,15 @@
+import { Where, Filter } from "./whereClause";
+export interface BasePermissionRule<Entity extends Object> {
+    where?: Where<Entity>;
+}
+
+export interface SelectPermissionRule<Entity extends Object> extends BasePermissionRule<Entity> {
+    /**
+     * limit the number of rows returned by the query(select action only)
+     */
+    limit?: number;
+    /**
+     * allow aggregations on the table (select action only)
+     */
+    allowAggregations?: boolean;
+}

package/src/types/whereClause.ts

@@ -0,0 +1,75 @@
+import { FindOptionsWhere, FindOperatorType, BaseEntity } from "typeorm";
+
+export type Where<Entity> = FindOptionsWhere<Entity>[] | FindOptionsWhere<Entity>
+
+export type ExclusiveKeys<T extends {}, Key = { [K in keyof T]: { [P in keyof T]?: P extends K ? T[P] : never } }> =
+    { [K in keyof Key]: Key[K] }[keyof Key];
+
+type StringParameters =
+    | "_eq"
+    | "_neq"
+    | "_gt"
+    | "_lt"
+    | "_gte"
+    | "_lte"
+    | "_like"
+    // | "_nlike"
+    | "_ilike"
+// | "_nilike"
+// | "_similar"
+// | "_nsimilar"
+// | "_regex"
+// | "_iregex"
+// | "_nregex"
+// | "_niregex"
+
+type ArrayParameters =
+    | "_in"
+// | "_nin"
+// | "_ceq"
+// | "_cne"
+// | "_cgt"
+// | "_clt"
+// | "_cgte"
+// | "_clte"
+type NullParameters = "_is_null"
+type JsonBParameters = "_contains" | "_contained_in" | "_has_key" | "_has_keys_any" | "_has_keys_all"
+
+type ExclusiveParameters = ExclusiveKeys<
+    { [key in StringParameters]?: string; } &
+    { [key in ArrayParameters]?: string[] } &
+    { [key in NullParameters]?: boolean }
+>
+type Subject<Entity extends Object> = {
+    [key in keyof Entity]?: ExclusiveParameters
+}
+export type ExclusiveArguments<Entity extends Object, T = {}, EntityParameters extends string | number | symbol = keyof Omit<Entity, keyof BaseEntity>> =
+    ExclusiveKeys<{ [key in EntityParameters]?: ExclusiveParameters | Subject<Entity> } & T>
+
+export type Filter<EntityParameters extends Object> = ExclusiveKeys<{
+    _and?: Filter<EntityParameters>[];
+    _or?: Filter<EntityParameters>[];
+    _not?: Filter<EntityParameters>
+}> | ExclusiveArguments<EntityParameters>
+
+export const Operators: Readonly<
+    Partial<Record<FindOperatorType, StringParameters | ArrayParameters>>
+> = {
+    // string
+    "equal": "_eq",
+    "not": "_neq",
+    "moreThan": "_gt",
+    "lessThan": "_lt",
+    "moreThanOrEqual": "_gte",
+    "lessThanOrEqual": "_lte",
+    "like": "_like",
+    "ilike": "_ilike",
+    // array
+    "in": "_in",
+}
+enum NullParams {
+    "isNull" = "_is_null"
+}
+
+// all typeorm operators FindOperatorType
+

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+   "compilerOptions": {
+      "strict": true,
+      "target": "es6",
+      "module": "ESNext",
+      "moduleResolution": "node",
+      "outDir": "./dist",
+      "emitDecoratorMetadata": true,
+      "experimentalDecorators": true,
+      "allowSyntheticDefaultImports": true,
+      "sourceMap": true,
+      "types": [
+         "node",
+         "jest"
+      ],
+      "rootDir": "./src"
+   },
+   "include": [
+      "./src/**/*.ts"
+   ],
+   "exclude": [
+      "node_modules",
+      "build",
+      "**/*.spec.ts"
+   ]
+}