@contember/graphql-client-system 1.2.0-rc.2

package/src/generated/CommonTypes.ts

@@ -0,0 +1,208 @@
+
+/**
+ * 
+ * This 'ImplementationType' is used for inheritance, let's see an example, if graphql schema is:
+ * 
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ * 
+ * Typescript code will be generated by like this:
+ * 
+ *     export ImplementationType<T extends string> =
+ *         T extends 'A' ? 'A' | ImplementationType<'B'> :
+ *         T extends 'B' ? 'B' | ImplementationType<'C'> :
+ *         T
+ *     ;
+ * 
+ * Let's see another example with abstract type, if the graphql schema is:
+ * 
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ * 
+ * Typescript code will be generated by like this:
+ * 
+ *     export ImplementationType<T extends string> =
+ *         T extends 'AbstractType' ? ImplemenationType<'Impl1'> | ImplementationType<'Impl2'> :
+ *         T
+ *     ;
+ */
+export type ImplementationType<T> = 
+    T extends 'Event' ? 'Event' | ImplementationType<'UpdateEvent'> | ImplementationType<'DeleteEvent'> | ImplementationType<'CreateEvent'> :
+    T
+;
+/**
+ * 
+ * This 'upcastTypes' is used for inheritance, let's see an example, if graphql schema is:
+ * 
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ * 
+ * Typescript code will be generated by like this:
+ * 
+ *     export function upcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         upcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ * 
+ *     function upcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'B':
+ *                 output.push('B');
+ *                 upcastTypes0('A', output);
+ *                 break;
+ *             case 'C':
+ *                 output.push('C');
+ *                 upcastTypes0('B', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }    
+ * 
+ * Let's see another example with abstract type, if the graphql schema is:
+ * 
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ * 
+ * Typescript code will be generated by like this:
+ * 
+ *     export function upcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         upcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ * 
+ *     function upcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'Impl1':
+ *                 output.push('Impl1');
+ *                 upcastTypes0('AbstractType', output);
+ *                 break;
+ *             case 'Impl2':
+ *                 output.push('Impl2');
+ *                 upcastTypes0('AbstractType', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }     
+ */
+
+export function upcastTypes(typeName: string): string[] {
+    const typeNames: string[] = [];
+    upcastTypes0(typeName, typeNames);
+    return typeNames;
+}
+
+function upcastTypes0(typeName: string, output: string[]) {
+    switch (typeName){
+        case 'UpdateEvent':
+            output.push('UpdateEvent');
+            upcastTypes0('Event', output);
+            break;
+        case 'DeleteEvent':
+            output.push('DeleteEvent');
+            upcastTypes0('Event', output);
+            break;
+        case 'CreateEvent':
+            output.push('CreateEvent');
+            upcastTypes0('Event', output);
+            break;
+        default:
+            output.push(typeName);
+            break;
+    }
+}
+
+/**
+ * 
+ * This 'downcastTypes' is used for inheritance, let's see an example, if graphql schema is:
+ * 
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ * 
+ * Typescript code will be generated by like this:
+ * 
+ *     export function downcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         downcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ * 
+ *     function downcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'A':
+ *                 output.push('A');
+ *                 downcastTypes0('B', output);
+ *                 break;
+ *             case 'B':
+ *                 output.push('B');
+ *                 downcastTypes0('C', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ * 
+ * Let's see another example with abstract type, if the graphql schema is:
+ * 
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ * 
+ * Typescript code will be generated by like this:
+ * 
+ *     export function downcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         downcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ * 
+ *     function downcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'AbstractType':
+ *                 downcastTypes0('Impl1', output);
+ *                 downcastTypes0('Impl2', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }   
+ */
+
+export function downcastTypes(typeName: string): string[] {
+    const typeNames: string[] = [];
+    downcastTypes0(typeName, typeNames);
+    return typeNames;
+}
+
+function downcastTypes0(typeName: string, output: string[]) {
+    switch (typeName){
+        case 'Event':
+            output.push('Event');
+            downcastTypes0('UpdateEvent', output);
+            downcastTypes0('DeleteEvent', output);
+            downcastTypes0('CreateEvent', output);
+            break;
+        default:
+            output.push(typeName);
+            break;
+    }
+}
+
+export type WithTypeName<T, TypeName extends string> =
+    T extends {readonly __typename: string} ?
+    T :
+    T & {readonly __typename: TypeName};
+;
+

package/src/generated/EnumInputMetadata.ts

@@ -0,0 +1,20 @@
+import { EnumInputMetadataBuilder } from 'graphql-ts-client-api';
+
+const builder = new EnumInputMetadataBuilder();
+
+builder.add("EventType");
+
+builder.add("EventsFilter", [
+    {name: "types", typeName: "EventType"}
+]);
+
+builder.add("EventsOrder");
+
+builder.add("EventsArgs", [
+    {name: "filter", typeName: "EventsFilter"}, 
+    {name: "order", typeName: "EventsOrder"}
+]);
+
+builder.add("MigrateErrorCode");
+
+export const ENUM_INPUT_METADATA = builder.build();

package/src/generated/enums/EventType.ts

@@ -0,0 +1 @@
+export type EventType = 'UPDATE' | 'DELETE' | 'CREATE';

package/src/generated/enums/EventsOrder.ts

@@ -0,0 +1,6 @@
+export type EventsOrder = 
+    'CREATED_AT_ASC' | 
+    'CREATED_AT_DESC' | 
+    'APPLIED_AT_ASC' | 
+    'APPLIED_AT_DESC'
+;

package/src/generated/enums/MigrateErrorCode.ts

@@ -0,0 +1,7 @@
+export type MigrateErrorCode = 
+    'MUST_FOLLOW_LATEST' | 
+    'ALREADY_EXECUTED' | 
+    'INVALID_FORMAT' | 
+    'INVALID_SCHEMA' | 
+    'MIGRATION_FAILED'
+;

package/src/generated/enums/index.ts

@@ -0,0 +1,3 @@
+export type {EventsOrder} from './EventsOrder';
+export type {EventType} from './EventType';
+export type {MigrateErrorCode} from './MigrateErrorCode';

package/src/generated/fetchers/CreateEventFetcher.ts

@@ -0,0 +1,308 @@
+import type { FieldOptions, DirectiveArgs } from 'graphql-ts-client-api';
+import { ENUM_INPUT_METADATA } from '../EnumInputMetadata';
+import type { ObjectFetcher } from 'graphql-ts-client-api';
+import { createFetcher, createFetchableType } from 'graphql-ts-client-api';
+import type { WithTypeName, ImplementationType } from '../CommonTypes';
+import { event$ } from './EventFetcher';
+import type {EventType} from '../enums';
+
+/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+export interface CreateEventFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'CreateEvent', T, TVariables> {
+
+    on<XName extends ImplementationType<'CreateEvent'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): CreateEventFetcher<
+        XName extends 'CreateEvent' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'CreateEvent'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'CreateEvent'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): CreateEventFetcher<T, TVariables>;
+
+
+    readonly __typename: CreateEventFetcher<T & {__typename: ImplementationType<'CreateEvent'>}, TVariables>;
+
+
+    readonly id: CreateEventFetcher<T & {readonly "id": string}, TVariables>;
+
+    "id+"<
+        XAlias extends string = "id", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"id", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~id": CreateEventFetcher<Omit<T, 'id'>, TVariables>;
+
+
+    readonly transactionId: CreateEventFetcher<T & {readonly "transactionId": string}, TVariables>;
+
+    "transactionId+"<
+        XAlias extends string = "transactionId", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"transactionId", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~transactionId": CreateEventFetcher<Omit<T, 'transactionId'>, TVariables>;
+
+
+    readonly identityId: CreateEventFetcher<T & {readonly "identityId": string}, TVariables>;
+
+    "identityId+"<
+        XAlias extends string = "identityId", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"identityId", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~identityId": CreateEventFetcher<Omit<T, 'identityId'>, TVariables>;
+
+
+    readonly identityDescription: CreateEventFetcher<T & {readonly "identityDescription": string}, TVariables>;
+
+    "identityDescription+"<
+        XAlias extends string = "identityDescription", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"identityDescription", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~identityDescription": CreateEventFetcher<Omit<T, 'identityDescription'>, TVariables>;
+
+
+    readonly description: CreateEventFetcher<T & {readonly "description": string}, TVariables>;
+
+    "description+"<
+        XAlias extends string = "description", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"description", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~description": CreateEventFetcher<Omit<T, 'description'>, TVariables>;
+
+
+    readonly createdAt: CreateEventFetcher<T & {readonly "createdAt": string}, TVariables>;
+
+    "createdAt+"<
+        XAlias extends string = "createdAt", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"createdAt", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~createdAt": CreateEventFetcher<Omit<T, 'createdAt'>, TVariables>;
+
+
+    readonly appliedAt: CreateEventFetcher<T & {readonly "appliedAt": string}, TVariables>;
+
+    "appliedAt+"<
+        XAlias extends string = "appliedAt", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"appliedAt", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~appliedAt": CreateEventFetcher<Omit<T, 'appliedAt'>, TVariables>;
+
+
+    readonly type: CreateEventFetcher<T & {readonly "type": EventType}, TVariables>;
+
+    "type+"<
+        XAlias extends string = "type", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"type", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: EventType} : 
+                {readonly [key in XAlias]: EventType}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~type": CreateEventFetcher<Omit<T, 'type'>, TVariables>;
+
+
+    readonly tableName: CreateEventFetcher<T & {readonly "tableName": string}, TVariables>;
+
+    "tableName+"<
+        XAlias extends string = "tableName", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"tableName", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~tableName": CreateEventFetcher<Omit<T, 'tableName'>, TVariables>;
+
+
+    readonly primaryKey: CreateEventFetcher<T & {readonly "primaryKey": ReadonlyArray<number | string>}, TVariables>;
+
+    "primaryKey+"<
+        XAlias extends string = "primaryKey", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"primaryKey", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<number | string>} : 
+                {readonly [key in XAlias]: ReadonlyArray<number | string>}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~primaryKey": CreateEventFetcher<Omit<T, 'primaryKey'>, TVariables>;
+
+
+    readonly newValues: CreateEventFetcher<T & {readonly "newValues": unknown}, TVariables>;
+
+    "newValues+"<
+        XAlias extends string = "newValues", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"newValues", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): CreateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: unknown} : 
+                {readonly [key in XAlias]: unknown}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~newValues": CreateEventFetcher<Omit<T, 'newValues'>, TVariables>;
+}
+
+export const createEvent$: CreateEventFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "CreateEvent", 
+            "OBJECT", 
+            [event$.fetchableType], 
+            [
+                "newValues"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const createEvent$$ = 
+    createEvent$
+        .id
+        .transactionId
+        .identityId
+        .identityDescription
+        .description
+        .createdAt
+        .appliedAt
+        .type
+        .tableName
+        .primaryKey
+        .newValues
+;