@constructive-io/react 0.19.6 → 0.19.8

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

@@ -15,12 +15,10 @@ export declare class TriggerFunctionModel {
     } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
         triggerFunctions: ConnectionResult<InferSelectResult<TriggerFunctionWithRelations, S>>;
     }>;
-    findFirst<S extends TriggerFunctionSelect>(args: FindFirstArgs<S, TriggerFunctionFilter> & {
+    findFirst<S extends TriggerFunctionSelect>(args: FindFirstArgs<S, TriggerFunctionFilter, TriggerFunctionOrderBy> & {
         select: S;
     } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
-        triggerFunctions: {
-            nodes: InferSelectResult<TriggerFunctionWithRelations, S>[];
-        };
+        triggerFunction: InferSelectResult<TriggerFunctionWithRelations, S> | null;
     }>;
     findOne<S extends TriggerFunctionSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class TriggerFunctionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('TriggerFunction', 'triggerFunctions', args.select, {
             where: args?.where,
-        }, 'TriggerFunctionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TriggerFunctionFilter', 'TriggerFunctionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'TriggerFunction',
-            fieldName: 'triggerFunctions',
+            fieldName: 'triggerFunction',
             document,
             variables,
+            transform: (data) => ({
+                triggerFunction: data.triggerFunctions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class UniqueConstraintModel {
     } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
         uniqueConstraints: ConnectionResult<InferSelectResult<UniqueConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends UniqueConstraintSelect>(args: FindFirstArgs<S, UniqueConstraintFilter> & {
+    findFirst<S extends UniqueConstraintSelect>(args: FindFirstArgs<S, UniqueConstraintFilter, UniqueConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
-        uniqueConstraints: {
-            nodes: InferSelectResult<UniqueConstraintWithRelations, S>[];
-        };
+        uniqueConstraint: InferSelectResult<UniqueConstraintWithRelations, S> | null;
     }>;
     findOne<S extends UniqueConstraintSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class UniqueConstraintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('UniqueConstraint', 'uniqueConstraints', args.select, {
             where: args?.where,
-        }, 'UniqueConstraintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UniqueConstraintFilter', 'UniqueConstraintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'UniqueConstraint',
-            fieldName: 'uniqueConstraints',
+            fieldName: 'uniqueConstraint',
             document,
             variables,
+            transform: (data) => ({
+                uniqueConstraint: data.uniqueConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class UsageSnapshotModel {
     } & StrictSelect<S, UsageSnapshotSelect>): QueryBuilder<{
         usageSnapshots: ConnectionResult<InferSelectResult<UsageSnapshotWithRelations, S>>;
     }>;
-    findFirst<S extends UsageSnapshotSelect>(args: FindFirstArgs<S, UsageSnapshotFilter> & {
+    findFirst<S extends UsageSnapshotSelect>(args: FindFirstArgs<S, UsageSnapshotFilter, UsageSnapshotOrderBy> & {
         select: S;
     } & StrictSelect<S, UsageSnapshotSelect>): QueryBuilder<{
-        usageSnapshots: {
-            nodes: InferSelectResult<UsageSnapshotWithRelations, S>[];
-        };
+        usageSnapshot: InferSelectResult<UsageSnapshotWithRelations, S> | null;
     }>;
     findOne<S extends UsageSnapshotSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class UsageSnapshotModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('UsageSnapshot', 'usageSnapshots', args.select, {
             where: args?.where,
-        }, 'UsageSnapshotFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UsageSnapshotFilter', 'UsageSnapshotOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'UsageSnapshot',
-            fieldName: 'usageSnapshots',
+            fieldName: 'usageSnapshot',
             document,
             variables,
+            transform: (data) => ({
+                usageSnapshot: data.usageSnapshots?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class UserModel {
     } & StrictSelect<S, UserSelect>): QueryBuilder<{
         users: ConnectionResult<InferSelectResult<UserWithRelations, S>>;
     }>;
-    findFirst<S extends UserSelect>(args: FindFirstArgs<S, UserFilter> & {
+    findFirst<S extends UserSelect>(args: FindFirstArgs<S, UserFilter, UserOrderBy> & {
         select: S;
     } & StrictSelect<S, UserSelect>): QueryBuilder<{
-        users: {
-            nodes: InferSelectResult<UserWithRelations, S>[];
-        };
+        user: InferSelectResult<UserWithRelations, S> | null;
     }>;
     findOne<S extends UserSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class UserModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('User', 'users', args.select, {
             where: args?.where,
-        }, 'UserFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UserFilter', 'UserOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'User',
-            fieldName: 'users',
+            fieldName: 'user',
             document,
             variables,
+            transform: (data) => ({
+                user: data.users?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class UserAuthModuleModel {
     } & StrictSelect<S, UserAuthModuleSelect>): QueryBuilder<{
         userAuthModules: ConnectionResult<InferSelectResult<UserAuthModuleWithRelations, S>>;
     }>;
-    findFirst<S extends UserAuthModuleSelect>(args: FindFirstArgs<S, UserAuthModuleFilter> & {
+    findFirst<S extends UserAuthModuleSelect>(args: FindFirstArgs<S, UserAuthModuleFilter, UserAuthModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, UserAuthModuleSelect>): QueryBuilder<{
-        userAuthModules: {
-            nodes: InferSelectResult<UserAuthModuleWithRelations, S>[];
-        };
+        userAuthModule: InferSelectResult<UserAuthModuleWithRelations, S> | null;
     }>;
     findOne<S extends UserAuthModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class UserAuthModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('UserAuthModule', 'userAuthModules', args.select, {
             where: args?.where,
-        }, 'UserAuthModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UserAuthModuleFilter', 'UserAuthModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'UserAuthModule',
-            fieldName: 'userAuthModules',
+            fieldName: 'userAuthModule',
             document,
             variables,
+            transform: (data) => ({
+                userAuthModule: data.userAuthModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class UserConnectedAccountModel {
     } & StrictSelect<S, UserConnectedAccountSelect>): QueryBuilder<{
         userConnectedAccounts: ConnectionResult<InferSelectResult<UserConnectedAccountWithRelations, S>>;
     }>;
-    findFirst<S extends UserConnectedAccountSelect>(args: FindFirstArgs<S, UserConnectedAccountFilter> & {
+    findFirst<S extends UserConnectedAccountSelect>(args: FindFirstArgs<S, UserConnectedAccountFilter, UserConnectedAccountOrderBy> & {
         select: S;
     } & StrictSelect<S, UserConnectedAccountSelect>): QueryBuilder<{
-        userConnectedAccounts: {
-            nodes: InferSelectResult<UserConnectedAccountWithRelations, S>[];
-        };
+        userConnectedAccount: InferSelectResult<UserConnectedAccountWithRelations, S> | null;
     }>;
     findOne<S extends UserConnectedAccountSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class UserConnectedAccountModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('UserConnectedAccount', 'userConnectedAccounts', args.select, {
             where: args?.where,
-        }, 'UserConnectedAccountFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UserConnectedAccountFilter', 'UserConnectedAccountOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'UserConnectedAccount',
-            fieldName: 'userConnectedAccounts',
+            fieldName: 'userConnectedAccount',
             document,
             variables,
+            transform: (data) => ({
+                userConnectedAccount: data.userConnectedAccounts?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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>;
+};