@constructive-io/sdk 0.0.2

package/esm/auth/orm/mutation/index.js

@@ -0,0 +1,198 @@
+import { QueryBuilder, buildCustomDocument } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export function createMutationOperations(client) {
+    return {
+        signOut: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SignOut',
+            fieldName: 'signOut',
+            ...buildCustomDocument('mutation', 'SignOut', 'signOut', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SignOutInput!',
+                },
+            ], connectionFieldsMap, 'SignOutPayload'),
+        }),
+        sendAccountDeletionEmail: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SendAccountDeletionEmail',
+            fieldName: 'sendAccountDeletionEmail',
+            ...buildCustomDocument('mutation', 'SendAccountDeletionEmail', 'sendAccountDeletionEmail', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SendAccountDeletionEmailInput!',
+                },
+            ], connectionFieldsMap, 'SendAccountDeletionEmailPayload'),
+        }),
+        checkPassword: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'CheckPassword',
+            fieldName: 'checkPassword',
+            ...buildCustomDocument('mutation', 'CheckPassword', 'checkPassword', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'CheckPasswordInput!',
+                },
+            ], connectionFieldsMap, 'CheckPasswordPayload'),
+        }),
+        confirmDeleteAccount: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ConfirmDeleteAccount',
+            fieldName: 'confirmDeleteAccount',
+            ...buildCustomDocument('mutation', 'ConfirmDeleteAccount', 'confirmDeleteAccount', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ConfirmDeleteAccountInput!',
+                },
+            ], connectionFieldsMap, 'ConfirmDeleteAccountPayload'),
+        }),
+        setPassword: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SetPassword',
+            fieldName: 'setPassword',
+            ...buildCustomDocument('mutation', 'SetPassword', 'setPassword', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SetPasswordInput!',
+                },
+            ], connectionFieldsMap, 'SetPasswordPayload'),
+        }),
+        verifyEmail: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'VerifyEmail',
+            fieldName: 'verifyEmail',
+            ...buildCustomDocument('mutation', 'VerifyEmail', 'verifyEmail', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'VerifyEmailInput!',
+                },
+            ], connectionFieldsMap, 'VerifyEmailPayload'),
+        }),
+        resetPassword: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ResetPassword',
+            fieldName: 'resetPassword',
+            ...buildCustomDocument('mutation', 'ResetPassword', 'resetPassword', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ResetPasswordInput!',
+                },
+            ], connectionFieldsMap, 'ResetPasswordPayload'),
+        }),
+        signInOneTimeToken: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SignInOneTimeToken',
+            fieldName: 'signInOneTimeToken',
+            ...buildCustomDocument('mutation', 'SignInOneTimeToken', 'signInOneTimeToken', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SignInOneTimeTokenInput!',
+                },
+            ], connectionFieldsMap, 'SignInOneTimeTokenPayload'),
+        }),
+        signIn: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SignIn',
+            fieldName: 'signIn',
+            ...buildCustomDocument('mutation', 'SignIn', 'signIn', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SignInInput!',
+                },
+            ], connectionFieldsMap, 'SignInPayload'),
+        }),
+        signUp: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SignUp',
+            fieldName: 'signUp',
+            ...buildCustomDocument('mutation', 'SignUp', 'signUp', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SignUpInput!',
+                },
+            ], connectionFieldsMap, 'SignUpPayload'),
+        }),
+        oneTimeToken: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'OneTimeToken',
+            fieldName: 'oneTimeToken',
+            ...buildCustomDocument('mutation', 'OneTimeToken', 'oneTimeToken', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'OneTimeTokenInput!',
+                },
+            ], connectionFieldsMap, 'OneTimeTokenPayload'),
+        }),
+        extendTokenExpires: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ExtendTokenExpires',
+            fieldName: 'extendTokenExpires',
+            ...buildCustomDocument('mutation', 'ExtendTokenExpires', 'extendTokenExpires', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ExtendTokenExpiresInput!',
+                },
+            ], connectionFieldsMap, 'ExtendTokenExpiresPayload'),
+        }),
+        forgotPassword: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ForgotPassword',
+            fieldName: 'forgotPassword',
+            ...buildCustomDocument('mutation', 'ForgotPassword', 'forgotPassword', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ForgotPasswordInput!',
+                },
+            ], connectionFieldsMap, 'ForgotPasswordPayload'),
+        }),
+        sendVerificationEmail: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SendVerificationEmail',
+            fieldName: 'sendVerificationEmail',
+            ...buildCustomDocument('mutation', 'SendVerificationEmail', 'sendVerificationEmail', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SendVerificationEmailInput!',
+                },
+            ], connectionFieldsMap, 'SendVerificationEmailPayload'),
+        }),
+        verifyPassword: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'VerifyPassword',
+            fieldName: 'verifyPassword',
+            ...buildCustomDocument('mutation', 'VerifyPassword', 'verifyPassword', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'VerifyPasswordInput!',
+                },
+            ], connectionFieldsMap, 'VerifyPasswordPayload'),
+        }),
+        verifyTotp: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'VerifyTotp',
+            fieldName: 'verifyTotp',
+            ...buildCustomDocument('mutation', 'VerifyTotp', 'verifyTotp', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'VerifyTotpInput!',
+                },
+            ], connectionFieldsMap, 'VerifyTotpPayload'),
+        }),
+    };
+}

package/esm/auth/orm/query/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Custom query operations
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { InferSelectResult, StrictSelect } from '../select-types';
+import type { User, UserSelect } from '../input-types';
+export declare function createQueryOperations(client: OrmClient): {
+    currentIpAddress: (options?: {
+        select?: Record<string, unknown>;
+    }) => QueryBuilder<{
+        currentIpAddress: string | null;
+    }>;
+    currentUserAgent: (options?: {
+        select?: Record<string, unknown>;
+    }) => QueryBuilder<{
+        currentUserAgent: string | null;
+    }>;
+    currentUserId: (options?: {
+        select?: Record<string, unknown>;
+    }) => QueryBuilder<{
+        currentUserId: string | null;
+    }>;
+    currentUser: <S extends UserSelect>(options: {
+        select: S;
+    } & StrictSelect<S, UserSelect>) => QueryBuilder<{
+        currentUser: InferSelectResult<User, S> | null;
+    }>;
+};

package/esm/auth/orm/query/index.js

@@ -0,0 +1,34 @@
+import { QueryBuilder, buildCustomDocument } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export function createQueryOperations(client) {
+    return {
+        currentIpAddress: (options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'CurrentIpAddress',
+            fieldName: 'currentIpAddress',
+            ...buildCustomDocument('query', 'CurrentIpAddress', 'currentIpAddress', options?.select, undefined, [], connectionFieldsMap, undefined),
+        }),
+        currentUserAgent: (options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'CurrentUserAgent',
+            fieldName: 'currentUserAgent',
+            ...buildCustomDocument('query', 'CurrentUserAgent', 'currentUserAgent', options?.select, undefined, [], connectionFieldsMap, undefined),
+        }),
+        currentUserId: (options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'CurrentUserId',
+            fieldName: 'currentUserId',
+            ...buildCustomDocument('query', 'CurrentUserId', 'currentUserId', options?.select, undefined, [], connectionFieldsMap, undefined),
+        }),
+        currentUser: (options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'CurrentUser',
+            fieldName: 'currentUser',
+            ...buildCustomDocument('query', 'CurrentUser', 'currentUser', options.select, undefined, [], connectionFieldsMap, 'User'),
+        }),
+    };
+}

package/esm/auth/orm/query-builder.d.ts

@@ -0,0 +1,89 @@
+import type { FieldNode } from 'graphql';
+import { OrmClient, QueryResult } from './client';
+export interface QueryBuilderConfig<TResult> {
+    client: OrmClient;
+    operation: 'query' | 'mutation';
+    operationName: string;
+    fieldName: string;
+    document: string;
+    variables?: Record<string, unknown>;
+    transform?: (data: any) => TResult;
+}
+export declare class QueryBuilder<TResult> {
+    private config;
+    constructor(config: QueryBuilderConfig<TResult>);
+    /**
+     * Execute the query and return a discriminated union result
+     * Use result.ok to check success, or .unwrap() to throw on error
+     */
+    execute(): Promise<QueryResult<TResult>>;
+    /**
+     * Execute and unwrap the result, throwing GraphQLRequestError on failure
+     * @throws {GraphQLRequestError} If the query returns errors
+     */
+    unwrap(): Promise<TResult>;
+    /**
+     * Execute and unwrap, returning defaultValue on error instead of throwing
+     */
+    unwrapOr<D>(defaultValue: D): Promise<TResult | D>;
+    /**
+     * Execute and unwrap, calling onError callback on failure
+     */
+    unwrapOrElse<D>(onError: (errors: import('./client').GraphQLError[]) => D): Promise<TResult | D>;
+    toGraphQL(): string;
+    getVariables(): Record<string, unknown> | undefined;
+}
+export declare function buildSelections(select: Record<string, unknown> | undefined, connectionFieldsMap?: Record<string, Record<string, string>>, entityType?: string): FieldNode[];
+export declare function buildFindManyDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+    orderBy?: string[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}, filterTypeName: string, orderByTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindFirstDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+}, filterTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCreateDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, data: TData, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateDocument<TSelect, TWhere extends {
+    id: string;
+}, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string, patchFieldName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateByPkDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, id: string | number, data: TData, inputTypeName: string, idFieldName: string, patchFieldName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindOneDocument<TSelect>(operationName: string, queryField: string, id: string | number, select: TSelect, idArgName: string, idTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteDocument<TWhere extends {
+    id: string;
+}, TSelect = undefined>(operationName: string, mutationField: string, entityField: string, where: TWhere, inputTypeName: string, select?: TSelect, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteByPkDocument<TSelect = undefined>(operationName: string, mutationField: string, entityField: string, id: string | number, inputTypeName: string, idFieldName: string, select?: TSelect, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCustomDocument<TSelect, TArgs>(operationType: 'query' | 'mutation', operationName: string, fieldName: string, select: TSelect, args: TArgs, variableDefinitions: Array<{
+    name: string;
+    type: string;
+}>, connectionFieldsMap?: Record<string, Record<string, string>>, entityType?: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};