typeorm-hasura 0.0.1

package/src/builders/Metadata.ts

@@ -0,0 +1,96 @@
+import { ActionBuildResult, DataSourceOptions } from "../types";
+import type * as Hasura from "hasura-metadata-types";
+import { generateSource } from "../mappers";
+
+export class MetadataBuilder {
+    private _metadata: Hasura.Metadata;
+
+    constructor() {
+        this._metadata = {
+            resource_version: 0,
+            metadata: {
+                version: 3,
+                sources: [],
+                actions: [],
+                custom_types: {
+                    input_objects: [],
+                    objects: [],
+                    scalars: [],
+                    enums: [],
+                },
+                // backend_configs?: BackendConfigs;
+                // remote_schemas?: RemoteSchema[];
+                // query_collections?: QueryCollection[];
+                // allowlist?: AllowList[];
+                // inherited_roles?: InheritedRole[];
+                // cron_triggers?: CronTrigger[];
+                // network?: Network;
+                // rest_endpoints?: RestEndpoint[];
+                // api_limits?: ApiLimits;
+                // graphql_schema_introspection?: GraphQLSchemaIntrospection;
+
+                /**
+                 * The EE Lite OpenTelemetry settings.
+                 *
+                 * ATTENTION: Both Lux and the EE Lite server allow configuring OpenTelemetry. Anyway, this only
+                 * represents the EE Lite one since Lux stores the OpenTelemetry settings by itself.
+                 */
+                // opentelemetry?: OpenTelemetry;
+            }
+        }
+    }
+
+    /**
+     * Adds a source to the metadata.
+     */
+    addSource(sourceOptions: DataSourceOptions) {
+        const source = generateSource(sourceOptions);
+        this._metadata.metadata.sources.push(source)
+        return this;
+    }
+
+    /**
+     * Adds multiple sources to the metadata.
+     */
+    addSources(sourceOptions: DataSourceOptions[]) {
+        sourceOptions.forEach(sourceOptions => this.addSource(sourceOptions));
+        return this;
+    }
+
+
+    // .addActions([
+    //     currencyConverterAction
+    // ])
+
+    /**
+     * Adds an action to the metadata.
+     */
+    addAction(action: ActionBuildResult) {
+        const metadata = this._metadata.metadata;
+        if(!metadata.actions || !metadata.custom_types?.input_objects) {
+            throw new Error("Metadata object is not initialized correctly.");
+        }
+        metadata.actions.push(...action.actions);
+        metadata.custom_types.input_objects?.push(...action.custom_types?.input_objects!);
+        metadata.custom_types.objects?.push(...action.custom_types?.objects!);
+        return this;
+    }
+
+    /**
+     * Adds multiple actions to the metadata.
+     */
+    addActions(actions: ActionBuildResult[]) {
+        actions.forEach(action => this.addAction(action));
+        return this;
+    }
+
+
+    /**
+     * Returns the metadata.
+     * 
+     * @note This method is not async because we might need to do some async stuff in the future.
+     */
+    getMetadata(): Hasura.Metadata | Promise<Hasura.Metadata> {
+        return this._metadata;
+    }
+}

package/src/builders/index.ts

@@ -0,0 +1,2 @@
+export * from './Action'
+export * from './Metadata'

package/src/decorators/Column.ts

@@ -0,0 +1,12 @@
+import { internalStorage } from "../internalStorage";
+import { ColumnOptions } from "../types";
+
+export function Column(options?: ColumnOptions): Function {
+    return function (object: Object, propertyName: string) {
+        internalStorage.pushColumnOptions(object, propertyName, options);
+    };
+}
+
+export {
+    Column as HasuraColumn,
+}

package/src/decorators/Entity.ts

@@ -0,0 +1,12 @@
+import { internalStorage } from "../internalStorage";
+import { EntityOptions } from "../types";
+
+export function Entity<Entity extends Object>(options: EntityOptions<Entity>): ClassDecorator {
+    return (target: object) => {
+        internalStorage.pushEntityOptions(target, options);
+    };
+}
+
+export {
+    Entity as HasuraEntity,
+}

package/src/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './Column';
+export * from './Entity';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './builders'
+export * from './decorators'
+export * as mappers from './mappers'
+export * from './types'
+export * from './internalStorage'

package/src/internalStorage.ts

@@ -0,0 +1,23 @@
+import { ColumnOptions, EntityOptions, ColumnMetadata, EntityTarget } from "./types";
+
+export const internalStorage = {
+    entityMetadata: new WeakMap<EntityTarget, EntityOptions<{}>>(),
+    pushEntityOptions(target: EntityTarget, options: EntityOptions<{}>) {
+        internalStorage.entityMetadata.set(target, options);
+    },
+    getEntityOptions<Entity extends Object = Object>(target: EntityTarget) {
+        return internalStorage.entityMetadata.get(target) as EntityOptions<Entity> | undefined
+},
+
+    columnMetadata: [] as Array<ColumnMetadata>,
+        pushColumnOptions(object: object, propertyName: string, options ?: ColumnOptions) {
+    internalStorage.columnMetadata.push({
+        object,
+        propertyName,
+        options,
+    });
+},
+getEntityColumnsOptionsList(target: EntityTarget) {
+    return internalStorage.columnMetadata.filter(column => column.object.constructor === target);
+},
+}

package/src/mappers/databaseUrl.spec.ts

@@ -0,0 +1,33 @@
+
+import { getDatabaseUrl } from "./databaseUrl";
+
+describe('mappers', () => {
+    describe('databaseUrl', () => {
+        it('should return postgres for postgres', () => {
+            expect(getDatabaseUrl({
+                dataSource: {
+                    name: 'default',
+                    // @ts-ignore
+                    type: 'postgres',
+                    options: {
+                        type: 'postgres',
+                        host: 'localhost',
+                        port: 5432,
+                        username: 'test-user',
+                        password: 'test-password',
+                        database: 'test-database',
+                    }
+                }
+            })).toEqual('postgres://test-user:test-password@localhost:5432/test-database');
+        });
+        it('should throw for unsupported type', () => {
+            expect(() => getDatabaseUrl({
+                dataSource: {
+                    name: 'default',
+                    // @ts-ignore
+                    type: 'mysql',
+                }
+            })).toThrow();
+        });
+    });
+})

package/src/mappers/databaseUrl.ts

@@ -0,0 +1,19 @@
+import { DataSourceOptions } from "../types";
+
+// currently hasura does not support object in database url
+export function getDatabaseUrl({ dataSource, databaseUrl }: DataSourceOptions): string {
+    if (databaseUrl) return databaseUrl;
+
+    const { options } = dataSource;
+    // check for postgres
+    if (options.type !== "postgres") {
+        throw new Error(`Unsupported data source type ${options.type}.`);
+    }
+    if (options.url) {
+        return options.url
+    }
+    if (typeof options.password !== 'string') {
+        throw new Error(`Does not support password as a function.`);
+    }
+    return `postgres://${options.username}:${options.password}@${options.host}:${options.port}/${options.database}`
+}

package/src/mappers/graphql.spec.ts

@@ -0,0 +1,124 @@
+import gql from "graphql-tag"
+import { getGraphQLDefinitions } from "./graphql"
+
+describe("convert graphql document to hasura defs", () => {
+    it("Base case", () => expect(getGraphQLDefinitions(gql`
+        type Query {
+            currencyConverter(CurrencyInfo: ConvertCurrencyInputParams!): ConvertedCurrency
+        }
+
+        input ConvertCurrencyInputParams {
+            from: String
+            to: String
+            amt: Int
+        }
+
+        type ConvertedCurrency {
+            date: String
+            info: ConvertedCurrencyInfo
+            query: ConvertedCurrencyQuery
+            result: Float
+            success: Boolean
+        }
+            
+        type ConvertedCurrencyInfo {
+            rate: Float
+        }
+
+        type ConvertedCurrencyQuery {
+            amount: Int
+            from: String
+            to: String
+        }
+    `)).toEqual({
+        baseActions: [
+            {
+                name: "currencyConverter",
+                definition: {
+                    "type": "query",
+                    output_type: "ConvertedCurrency",
+                    "arguments": [
+                        {
+                            "name": "CurrencyInfo",
+                            "type": "ConvertCurrencyInputParams!"
+                        }
+                    ],
+                }
+            }
+        ],
+        "custom_types": {
+            "input_objects": [
+                {
+                    "name": "ConvertCurrencyInputParams",
+                    "fields": [
+                        {
+                            "name": "from",
+                            "type": "String"
+                        },
+                        {
+                            "name": "to",
+                            "type": "String"
+                        },
+                        {
+                            "name": "amt",
+                            "type": "Int"
+                        }
+                    ]
+                }
+            ],
+            "objects": [
+                {
+                    "name": "ConvertedCurrency",
+                    "fields": [
+                        {
+                            "name": "date",
+                            "type": "String"
+                        },
+                        {
+                            "name": "info",
+                            "type": "ConvertedCurrencyInfo"
+                        },
+                        {
+                            "name": "query",
+                            "type": "ConvertedCurrencyQuery"
+                        },
+                        {
+                            "name": "result",
+                            "type": "Float"
+                        },
+                        {
+                            "name": "success",
+                            "type": "Boolean"
+                        }
+                    ]
+                },
+                {
+                    "name": "ConvertedCurrencyInfo",
+                    "fields": [
+                        {
+                            "name": "rate",
+                            "type": "Float"
+                        }
+                    ]
+                },
+                {
+                    "name": "ConvertedCurrencyQuery",
+                    "fields": [
+                        {
+                            "name": "amount",
+                            "type": "Int"
+                        },
+                        {
+                            "name": "from",
+                            "type": "String"
+                        },
+                        {
+                            "name": "to",
+                            "type": "String"
+                        }
+                    ]
+                },
+            ]
+        }
+    }))
+})

package/src/mappers/graphql.ts

@@ -0,0 +1,61 @@
+import { DocumentNode, FieldDefinitionNode, InputValueDefinitionNode } from "graphql";
+import type * as Hasura from "hasura-metadata-types";
+import { GraphQlMetadataForAction } from "../types";
+
+function mapFields(values: readonly InputValueDefinitionNode[] | readonly FieldDefinitionNode[]): Hasura.InputArgument[] {
+    return values.map(value => ({
+        name: value.name.value,
+        // @ts-ignore
+        type: value.type.kind === "NonNullType" ? value.type.type.name.value + "!" : value.type.name.value,
+    }));
+}
+
+export function getGraphQLDefinitions(document: DocumentNode): GraphQlMetadataForAction {
+    const result: GraphQlMetadataForAction = {
+        baseActions: [],
+        custom_types: {
+            input_objects: [],
+            objects: [],
+        },
+    };
+    for (const definition of document.definitions) {
+        // type Query or type Mutation
+        if (definition.kind === "ObjectTypeDefinition" && ["Query", "Mutation"].includes(definition.name.value)) {
+            if (!definition.fields)
+                throw new Error(`No fields found in definition for ${definition.name.value}`);
+            for (const field of definition.fields) {
+                const type = definition.name.value.toLowerCase();
+                if (type !== "query" as const && type !== "mutation" as const)
+                    throw new Error(`Invalid type ${type} for field ${field.name.value}`);
+
+                let output_type: string;
+                if (field.type.kind === "NamedType") {
+                    output_type = field.type.name.value;
+                } else
+                    throw new Error(`Invalid type ${field.type.kind} for field ${field.name.value}`);
+
+                result.baseActions.push({
+                    name: field.name.value,
+                    definition: {
+                        type,
+                        output_type,
+                        arguments: mapFields(field.arguments || []),
+                    }
+                })
+            }
+            continue
+        }
+
+        // InputObjectTypeDefinition or ObjectTypeDefinition
+        else if (definition.kind === "InputObjectTypeDefinition" || definition.kind === "ObjectTypeDefinition") {
+            const type = definition.kind === "InputObjectTypeDefinition" ? "input_objects" : "objects";
+            result.custom_types[type]!.push({
+                name: definition.name.value,
+                fields: mapFields(definition.fields || []),
+            })
+        }
+
+        else throw new Error(`Invalid definition ${definition.kind}`);
+    }
+    return result;
+}

package/src/mappers/hasuraKind.spec.ts

@@ -0,0 +1,12 @@
+import { getHasuraKind } from "./hasuraKind";
+
+describe('mappers', () => {
+    describe('hasuraKind', () => {
+        it('should return postgres for postgres', () => {
+            expect(getHasuraKind('postgres')).toEqual('postgres');
+        });
+        it('should throw for unsupported type', () => {
+            expect(() => getHasuraKind('mysql')).toThrow();
+        });
+    });
+})

package/src/mappers/hasuraKind.ts

@@ -0,0 +1,11 @@
+import type * as TypeORM from "typeorm";
+import type * as Hasura from "hasura-metadata-types";
+
+export function getHasuraKind(type: TypeORM.DataSourceOptions["type"]): Hasura.Source["kind"] {
+    switch (type) {
+        case "postgres":
+            return "postgres";
+        default:
+            throw new Error(`Unsupported data source type ${type}.`);
+    }
+}

package/src/mappers/index.ts

@@ -0,0 +1,3 @@
+export * from './databaseUrl'
+export * from './hasuraKind'
+export * from './source'

package/src/mappers/permissions.spec.ts

@@ -0,0 +1,143 @@
+import { EntityOptions, ColumnMetadata, DataSourceOptions } from "../types";
+import { BaseEntity } from "typeorm"
+import { generatePermissions, PermissionResult } from "./permissions"
+import { Org } from "../../dev-playground/entity"
+
+type Cases<Entity extends BaseEntity> = {
+    input: EntityOptions<Entity>,
+    output: PermissionResult
+}
+
+const dataSourceOptions = {} as unknown as DataSourceOptions
+
+let TestColumns: ColumnMetadata[] = [
+    {
+        object: 1,
+        propertyName: "id",
+        options: {
+            permissions: {
+                user: ["select", "update"]
+            }
+        }
+    }
+]
+
+const cases: Cases<Org>[] = [
+    {
+        input: {
+            permissions: {
+                user: {
+                    where: {
+                        id: "1"
+                    },
+                    select: true,
+                }
+            }
+        },
+        output: {
+            insert_permissions: [],
+            select_permissions: [{
+                role: "user",
+                permission: {
+                    columns: ["id"],
+                    filter: {
+                        id: { _eq: "1" }
+                    }
+                }
+            }],
+            update_permissions: [],
+            delete_permissions: [],
+        }
+    },
+    {
+        input: {
+            permissions: {
+                user: {
+                    where: {
+                        id: "1"
+                    },
+                    select: true,
+                    update: true,
+                }
+            }
+        },
+        output: {
+            insert_permissions: [],
+            select_permissions: [{
+                role: "user",
+                permission: {
+                    columns: ["id"],
+                    filter: {
+                        id: { _eq: "1" }
+                    }
+                }
+            }],
+            update_permissions: [{
+                role: "user",
+                permission: {
+                    columns: ["id"],
+                    filter: {
+                        id: { _eq: "1" }
+                    }
+                }
+            }],
+            delete_permissions: [],
+        }
+    },
+    {
+        input: {
+            permissions: {
+                user: {
+                    where: {
+                        id: "1"
+                    },
+                    select: true,
+                    update: {
+                        where: {
+                            users: {
+                                id: "1"
+                            }
+                        },
+                    },
+                }
+            }
+        },
+        output: {
+            insert_permissions: [],
+            select_permissions: [{
+                role: "user",
+                permission: {
+                    columns: ["id"],
+                    filter: {
+                        id: { _eq: "1" }
+                    }
+                }
+            }],
+            update_permissions: [{
+                role: "user",
+                permission: {
+                    columns: ["id"],
+                    filter: {
+                        _and: [
+                            { id: { _eq: "1" } },
+                            {
+                                users: {
+                                    id: { _eq: "1" }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }],
+            delete_permissions: [],
+        }
+    }
+]
+
+describe("convert whereTypeorm to hasuraObj", () => {
+    cases.forEach(({ input, output }) =>
+        it("input to Equal output", () =>
+            expect(generatePermissions(dataSourceOptions, input, TestColumns))
+                .toEqual(output))
+    )
+})

package/src/mappers/permissions.ts

@@ -0,0 +1,84 @@
+import type * as Hasura from "hasura-metadata-types";
+import { ColumnMetadata, DataSourceOptions, EntityOptions, UserActionType } from "../types";
+import { convertWhereClause } from "./whereClause"
+export type PermissionResult = Required<Pick<
+    Hasura.MetadataTable,
+    "insert_permissions" | "select_permissions" | "update_permissions" | "delete_permissions"
+>>
+
+export function generatePermissions<Entity extends Object = Object>(
+    dataSourceOptions: DataSourceOptions,
+    entityOptions: EntityOptions<Entity> | undefined,
+    columnMetadata: ColumnMetadata[]
+): PermissionResult {
+
+    const result: PermissionResult = {
+        insert_permissions: [],
+        select_permissions: [],
+        update_permissions: [],
+        delete_permissions: [],
+    }
+    if (!entityOptions?.permissions)
+        return result;
+
+    const { permissions } = entityOptions
+
+    for (let key in permissions) {
+        const permission = permissions[key]
+        let { where, select, update, insert, delete: myDelete } = permission
+
+        if (select) {
+            if (select === true) select = {}
+            result.select_permissions.push({
+                role: key,
+                permission: {
+                    columns: columnNames(columnMetadata, key, "select"),
+                    filter: convertWhereClause<Entity>(where, select.where),
+                    limit: select.limit || dataSourceOptions.defaultSelectPermissionLimit,
+                }
+            })
+        }
+        if (update) {
+            if (update === true) update = {}
+            result.update_permissions.push({
+                role: key,
+                permission: {
+                    columns: columnNames(columnMetadata, key, "update"),
+                    filter: convertWhereClause<Entity>(where, update.where)
+                }
+            })
+        }
+
+        if (insert) {
+            if (insert === true) insert = {}
+            if (insert.where) throw new Error("u can not select while inserting something")
+            result.insert_permissions.push({
+                role: key,
+                permission: {
+                    columns: columnNames(columnMetadata, key, "insert"),
+                }
+            })
+        }
+
+        if (myDelete) {
+            if (myDelete === true) myDelete = {}
+            result.delete_permissions.push({
+                role: key,
+                permission: {
+                    filter: convertWhereClause<Entity>(where, myDelete.where)
+                }
+            })
+        }
+    }
+    return result
+}
+
+function columnNames(arr: ColumnMetadata[], roleName: string, method: UserActionType): string[] {
+    return arr.filter(column => {
+        let permission = column.options?.permissions?.[roleName]
+        if (typeof permission == "boolean" || permission == undefined) return false;
+        if (typeof permission == "string")
+            permission = [permission]
+        return permission.includes(method)
+    }).map(i => i.propertyName)
+}