@constructive-io/react 0.19.5 → 0.19.7

package/esm/public/orm/models/usersModule.d.ts

@@ -15,12 +15,10 @@ export declare class UsersModuleModel {
     } & StrictSelect<S, UsersModuleSelect>): QueryBuilder<{
         usersModules: ConnectionResult<InferSelectResult<UsersModuleWithRelations, S>>;
     }>;
-    findFirst<S extends UsersModuleSelect>(args: FindFirstArgs<S, UsersModuleFilter> & {
+    findFirst<S extends UsersModuleSelect>(args: FindFirstArgs<S, UsersModuleFilter, UsersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, UsersModuleSelect>): QueryBuilder<{
-        usersModules: {
-            nodes: InferSelectResult<UsersModuleWithRelations, S>[];
-        };
+        usersModule: InferSelectResult<UsersModuleWithRelations, S> | null;
     }>;
     findOne<S extends UsersModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/usersModule.js

@@ -27,14 +27,18 @@ export class UsersModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('UsersModule', 'usersModules', args.select, {
             where: args?.where,
-        }, 'UsersModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UsersModuleFilter', 'UsersModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'UsersModule',
-            fieldName: 'usersModules',
+            fieldName: 'usersModule',
             document,
             variables,
+            transform: (data) => ({
+                usersModule: data.usersModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/view.d.ts

@@ -15,12 +15,10 @@ export declare class ViewModel {
     } & StrictSelect<S, ViewSelect>): QueryBuilder<{
         views: ConnectionResult<InferSelectResult<ViewWithRelations, S>>;
     }>;
-    findFirst<S extends ViewSelect>(args: FindFirstArgs<S, ViewFilter> & {
+    findFirst<S extends ViewSelect>(args: FindFirstArgs<S, ViewFilter, ViewOrderBy> & {
         select: S;
     } & StrictSelect<S, ViewSelect>): QueryBuilder<{
-        views: {
-            nodes: InferSelectResult<ViewWithRelations, S>[];
-        };
+        view: InferSelectResult<ViewWithRelations, S> | null;
     }>;
     findOne<S extends ViewSelect>(args: {
         id: string;

package/esm/public/orm/models/view.js

@@ -27,14 +27,18 @@ export class ViewModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('View', 'views', args.select, {
             where: args?.where,
-        }, 'ViewFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewFilter', 'ViewOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'View',
-            fieldName: 'views',
+            fieldName: 'view',
             document,
             variables,
+            transform: (data) => ({
+                view: data.views?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/viewGrant.d.ts

@@ -15,12 +15,10 @@ export declare class ViewGrantModel {
     } & StrictSelect<S, ViewGrantSelect>): QueryBuilder<{
         viewGrants: ConnectionResult<InferSelectResult<ViewGrantWithRelations, S>>;
     }>;
-    findFirst<S extends ViewGrantSelect>(args: FindFirstArgs<S, ViewGrantFilter> & {
+    findFirst<S extends ViewGrantSelect>(args: FindFirstArgs<S, ViewGrantFilter, ViewGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, ViewGrantSelect>): QueryBuilder<{
-        viewGrants: {
-            nodes: InferSelectResult<ViewGrantWithRelations, S>[];
-        };
+        viewGrant: InferSelectResult<ViewGrantWithRelations, S> | null;
     }>;
     findOne<S extends ViewGrantSelect>(args: {
         id: string;

package/esm/public/orm/models/viewGrant.js

@@ -27,14 +27,18 @@ export class ViewGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ViewGrant', 'viewGrants', args.select, {
             where: args?.where,
-        }, 'ViewGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewGrantFilter', 'ViewGrantOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ViewGrant',
-            fieldName: 'viewGrants',
+            fieldName: 'viewGrant',
             document,
             variables,
+            transform: (data) => ({
+                viewGrant: data.viewGrants?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/viewRule.d.ts

@@ -15,12 +15,10 @@ export declare class ViewRuleModel {
     } & StrictSelect<S, ViewRuleSelect>): QueryBuilder<{
         viewRules: ConnectionResult<InferSelectResult<ViewRuleWithRelations, S>>;
     }>;
-    findFirst<S extends ViewRuleSelect>(args: FindFirstArgs<S, ViewRuleFilter> & {
+    findFirst<S extends ViewRuleSelect>(args: FindFirstArgs<S, ViewRuleFilter, ViewRuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ViewRuleSelect>): QueryBuilder<{
-        viewRules: {
-            nodes: InferSelectResult<ViewRuleWithRelations, S>[];
-        };
+        viewRule: InferSelectResult<ViewRuleWithRelations, S> | null;
     }>;
     findOne<S extends ViewRuleSelect>(args: {
         id: string;

package/esm/public/orm/models/viewRule.js

@@ -27,14 +27,18 @@ export class ViewRuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ViewRule', 'viewRules', args.select, {
             where: args?.where,
-        }, 'ViewRuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewRuleFilter', 'ViewRuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ViewRule',
-            fieldName: 'viewRules',
+            fieldName: 'viewRule',
             document,
             variables,
+            transform: (data) => ({
+                viewRule: data.viewRules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/viewTable.d.ts

@@ -15,12 +15,10 @@ export declare class ViewTableModel {
     } & StrictSelect<S, ViewTableSelect>): QueryBuilder<{
         viewTables: ConnectionResult<InferSelectResult<ViewTableWithRelations, S>>;
     }>;
-    findFirst<S extends ViewTableSelect>(args: FindFirstArgs<S, ViewTableFilter> & {
+    findFirst<S extends ViewTableSelect>(args: FindFirstArgs<S, ViewTableFilter, ViewTableOrderBy> & {
         select: S;
     } & StrictSelect<S, ViewTableSelect>): QueryBuilder<{
-        viewTables: {
-            nodes: InferSelectResult<ViewTableWithRelations, S>[];
-        };
+        viewTable: InferSelectResult<ViewTableWithRelations, S> | null;
     }>;
     findOne<S extends ViewTableSelect>(args: {
         id: string;

package/esm/public/orm/models/viewTable.js

@@ -27,14 +27,18 @@ export class ViewTableModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ViewTable', 'viewTables', args.select, {
             where: args?.where,
-        }, 'ViewTableFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewTableFilter', 'ViewTableOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ViewTable',
-            fieldName: 'viewTables',
+            fieldName: 'viewTable',
             document,
             variables,
+            transform: (data) => ({
+                viewTable: data.viewTables?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/webauthnAuthModule.d.ts

@@ -15,12 +15,10 @@ export declare class WebauthnAuthModuleModel {
     } & StrictSelect<S, WebauthnAuthModuleSelect>): QueryBuilder<{
         webauthnAuthModules: ConnectionResult<InferSelectResult<WebauthnAuthModuleWithRelations, S>>;
     }>;
-    findFirst<S extends WebauthnAuthModuleSelect>(args: FindFirstArgs<S, WebauthnAuthModuleFilter> & {
+    findFirst<S extends WebauthnAuthModuleSelect>(args: FindFirstArgs<S, WebauthnAuthModuleFilter, WebauthnAuthModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, WebauthnAuthModuleSelect>): QueryBuilder<{
-        webauthnAuthModules: {
-            nodes: InferSelectResult<WebauthnAuthModuleWithRelations, S>[];
-        };
+        webauthnAuthModule: InferSelectResult<WebauthnAuthModuleWithRelations, S> | null;
     }>;
     findOne<S extends WebauthnAuthModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/webauthnAuthModule.js

@@ -27,14 +27,18 @@ export class WebauthnAuthModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('WebauthnAuthModule', 'webauthnAuthModules', args.select, {
             where: args?.where,
-        }, 'WebauthnAuthModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnAuthModuleFilter', 'WebauthnAuthModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'WebauthnAuthModule',
-            fieldName: 'webauthnAuthModules',
+            fieldName: 'webauthnAuthModule',
             document,
             variables,
+            transform: (data) => ({
+                webauthnAuthModule: data.webauthnAuthModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/webauthnCredential.d.ts

@@ -15,12 +15,10 @@ export declare class WebauthnCredentialModel {
     } & StrictSelect<S, WebauthnCredentialSelect>): QueryBuilder<{
         webauthnCredentials: ConnectionResult<InferSelectResult<WebauthnCredentialWithRelations, S>>;
     }>;
-    findFirst<S extends WebauthnCredentialSelect>(args: FindFirstArgs<S, WebauthnCredentialFilter> & {
+    findFirst<S extends WebauthnCredentialSelect>(args: FindFirstArgs<S, WebauthnCredentialFilter, WebauthnCredentialOrderBy> & {
         select: S;
     } & StrictSelect<S, WebauthnCredentialSelect>): QueryBuilder<{
-        webauthnCredentials: {
-            nodes: InferSelectResult<WebauthnCredentialWithRelations, S>[];
-        };
+        webauthnCredential: InferSelectResult<WebauthnCredentialWithRelations, S> | null;
     }>;
     findOne<S extends WebauthnCredentialSelect>(args: {
         id: string;

package/esm/public/orm/models/webauthnCredential.js

@@ -27,14 +27,18 @@ export class WebauthnCredentialModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('WebauthnCredential', 'webauthnCredentials', args.select, {
             where: args?.where,
-        }, 'WebauthnCredentialFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnCredentialFilter', 'WebauthnCredentialOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'WebauthnCredential',
-            fieldName: 'webauthnCredentials',
+            fieldName: 'webauthnCredential',
             document,
             variables,
+            transform: (data) => ({
+                webauthnCredential: data.webauthnCredentials?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/webauthnCredentialsModule.d.ts

@@ -15,12 +15,10 @@ export declare class WebauthnCredentialsModuleModel {
     } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
         webauthnCredentialsModules: ConnectionResult<InferSelectResult<WebauthnCredentialsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends WebauthnCredentialsModuleSelect>(args: FindFirstArgs<S, WebauthnCredentialsModuleFilter> & {
+    findFirst<S extends WebauthnCredentialsModuleSelect>(args: FindFirstArgs<S, WebauthnCredentialsModuleFilter, WebauthnCredentialsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
-        webauthnCredentialsModules: {
-            nodes: InferSelectResult<WebauthnCredentialsModuleWithRelations, S>[];
-        };
+        webauthnCredentialsModule: InferSelectResult<WebauthnCredentialsModuleWithRelations, S> | null;
     }>;
     findOne<S extends WebauthnCredentialsModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/webauthnCredentialsModule.js

@@ -27,14 +27,18 @@ export class WebauthnCredentialsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('WebauthnCredentialsModule', 'webauthnCredentialsModules', args.select, {
             where: args?.where,
-        }, 'WebauthnCredentialsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnCredentialsModuleFilter', 'WebauthnCredentialsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'WebauthnCredentialsModule',
-            fieldName: 'webauthnCredentialsModules',
+            fieldName: 'webauthnCredentialsModule',
             document,
             variables,
+            transform: (data) => ({
+                webauthnCredentialsModule: data.webauthnCredentialsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/webauthnSetting.d.ts

@@ -15,12 +15,10 @@ export declare class WebauthnSettingModel {
     } & StrictSelect<S, WebauthnSettingSelect>): QueryBuilder<{
         webauthnSettings: ConnectionResult<InferSelectResult<WebauthnSettingWithRelations, S>>;
     }>;
-    findFirst<S extends WebauthnSettingSelect>(args: FindFirstArgs<S, WebauthnSettingFilter> & {
+    findFirst<S extends WebauthnSettingSelect>(args: FindFirstArgs<S, WebauthnSettingFilter, WebauthnSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, WebauthnSettingSelect>): QueryBuilder<{
-        webauthnSettings: {
-            nodes: InferSelectResult<WebauthnSettingWithRelations, S>[];
-        };
+        webauthnSetting: InferSelectResult<WebauthnSettingWithRelations, S> | null;
     }>;
     findOne<S extends WebauthnSettingSelect>(args: {
         id: string;

package/esm/public/orm/models/webauthnSetting.js

@@ -27,14 +27,18 @@ export class WebauthnSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('WebauthnSetting', 'webauthnSettings', args.select, {
             where: args?.where,
-        }, 'WebauthnSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnSettingFilter', 'WebauthnSettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'WebauthnSetting',
-            fieldName: 'webauthnSettings',
+            fieldName: 'webauthnSetting',
             document,
             variables,
+            transform: (data) => ({
+                webauthnSetting: data.webauthnSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -48,7 +48,8 @@ export declare function buildFindManyDocument<TSelect, TWhere>(operationName: st
 };
 export declare function buildFindFirstDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
     where?: TWhere;
-}, filterTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    orderBy?: string[];
+}, filterTypeName: string, orderByTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
     document: string;
     variables: Record<string, unknown>;
 };
@@ -91,3 +92,19 @@ export declare function buildCustomDocument<TSelect, TArgs>(operationType: 'quer
     document: string;
     variables: Record<string, unknown>;
 };
+export declare function buildBulkInsertDocument<TSelect, TData>(operationName: string, mutationField: string, select: TSelect, data: TData[], inputTypeName: string, onConflict?: unknown, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkUpsertDocument<TSelect, TData>(operationName: string, mutationField: string, select: TSelect, data: TData[], inputTypeName: string, onConflict: unknown, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkUpdateDocument<TSelect, TWhere, TData>(operationName: string, mutationField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkDeleteDocument<TSelect, TWhere>(operationName: string, mutationField: string, select: TSelect, where: TWhere, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};

package/esm/public/orm/query-builder.js

@@ -199,7 +199,7 @@ export function buildFindManyDocument(operationName, queryField, select, args, f
     });
     return { document: print(document), variables };
 }
-export function buildFindFirstDocument(operationName, queryField, select, args, filterTypeName, connectionFieldsMap) {
+export function buildFindFirstDocument(operationName, queryField, select, args, filterTypeName, orderByTypeName, connectionFieldsMap) {
     const selections = select
         ? buildSelections(select, connectionFieldsMap, operationName)
         : [t.field({ name: 'id' })];
@@ -213,6 +213,11 @@ export function buildFindFirstDocument(operationName, queryField, select, args,
         typeName: filterTypeName,
         value: args.where,
     }, variableDefinitions, queryArgs, variables);
+    addVariable({
+        varName: 'orderBy',
+        typeName: '[' + orderByTypeName + '!]',
+        value: args.orderBy?.length ? args.orderBy : undefined,
+    }, variableDefinitions, queryArgs, variables);
     const document = t.document({
         definitions: [
             t.operationDefinition({
@@ -595,3 +600,105 @@ function buildValueAst(value) {
     }
     throw new Error('Unsupported value type: ' + typeof value);
 }
+// ============================================================================
+// Bulk Mutation Document Builders
+// ============================================================================
+export function buildBulkInsertDocument(operationName, mutationField, select, data, inputTypeName, onConflict, connectionFieldsMap) {
+    const selections = select
+        ? buildSelections(select, connectionFieldsMap, operationName)
+        : [t.field({ name: 'id' })];
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({ name: 'affectedCount' }),
+                t.field({
+                    name: 'returning',
+                    selectionSet: t.selectionSet({ selections }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                values: data,
+                ...(onConflict ? { onConflict } : {}),
+            },
+        },
+    };
+}
+export function buildBulkUpsertDocument(operationName, mutationField, select, data, inputTypeName, onConflict, connectionFieldsMap) {
+    const selections = select
+        ? buildSelections(select, connectionFieldsMap, operationName)
+        : [t.field({ name: 'id' })];
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({ name: 'affectedCount' }),
+                t.field({
+                    name: 'returning',
+                    selectionSet: t.selectionSet({ selections }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                values: data,
+                onConflict,
+            },
+        },
+    };
+}
+export function buildBulkUpdateDocument(operationName, mutationField, select, where, data, inputTypeName, connectionFieldsMap) {
+    const selections = select
+        ? buildSelections(select, connectionFieldsMap, operationName)
+        : [t.field({ name: 'id' })];
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({ name: 'affectedCount' }),
+                t.field({
+                    name: 'returning',
+                    selectionSet: t.selectionSet({ selections }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                where,
+                patch: data,
+            },
+        },
+    };
+}
+export function buildBulkDeleteDocument(operationName, mutationField, select, where, inputTypeName, connectionFieldsMap) {
+    const selections = select
+        ? buildSelections(select, connectionFieldsMap, operationName)
+        : [t.field({ name: 'id' })];
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({ name: 'affectedCount' }),
+                t.field({
+                    name: 'returning',
+                    selectionSet: t.selectionSet({ selections }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                where,
+            },
+        },
+    };
+}

package/esm/public/orm/select-types.d.ts

@@ -24,9 +24,10 @@ export interface FindManyArgs<TSelect, TWhere, TOrderBy = never> {
     before?: string;
     offset?: number;
 }
-export interface FindFirstArgs<TSelect, TWhere> {
+export interface FindFirstArgs<TSelect, TWhere, TOrderBy> {
     select?: TSelect;
     where?: TWhere;
+    orderBy?: TOrderBy[];
 }
 export interface CreateArgs<TSelect, TData> {
     data: TData;
@@ -44,6 +45,29 @@ export interface DeleteArgs<TWhere, TSelect = undefined> {
     where: TWhere;
     select?: TSelect;
 }
+export interface BulkInsertArgs<TSelect, TData, TOnConflict = unknown> {
+    data: TData[];
+    select?: TSelect;
+    onConflict?: TOnConflict;
+}
+export interface BulkUpsertArgs<TSelect, TData, TOnConflict = unknown> {
+    data: TData[];
+    select?: TSelect;
+    onConflict: TOnConflict;
+}
+export interface BulkUpdateArgs<TSelect, TWhere, TData> {
+    where: TWhere;
+    data: TData;
+    select?: TSelect;
+}
+export interface BulkDeleteArgs<TSelect, TWhere> {
+    where: TWhere;
+    select?: TSelect;
+}
+export interface BulkMutationResult<T> {
+    affectedCount: number;
+    returning: T[];
+}
 type DepthLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
 type DecrementDepth = {
     0: 0;