@constructive-io/sdk 0.21.6 → 0.21.8

package/public/orm/models/trigger.d.ts

@@ -15,12 +15,10 @@ export declare class TriggerModel {
     } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
         triggers: ConnectionResult<InferSelectResult<TriggerWithRelations, S>>;
     }>;
-    findFirst<S extends TriggerSelect>(args: FindFirstArgs<S, TriggerFilter> & {
+    findFirst<S extends TriggerSelect>(args: FindFirstArgs<S, TriggerFilter, TriggerOrderBy> & {
         select: S;
     } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
-        triggers: {
-            nodes: InferSelectResult<TriggerWithRelations, S>[];
-        };
+        trigger: InferSelectResult<TriggerWithRelations, S> | null;
     }>;
     findOne<S extends TriggerSelect>(args: {
         id: string;

package/public/orm/models/trigger.js

@@ -30,14 +30,18 @@ class TriggerModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('Trigger', 'triggers', args.select, {
             where: args?.where,
-        }, 'TriggerFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TriggerFilter', 'TriggerOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Trigger',
-            fieldName: 'triggers',
+            fieldName: 'trigger',
             document,
             variables,
+            transform: (data) => ({
+                trigger: data.triggers?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/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/public/orm/models/triggerFunction.js

@@ -30,14 +30,18 @@ class TriggerFunctionModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('TriggerFunction', 'triggerFunctions', args.select, {
             where: args?.where,
-        }, 'TriggerFunctionFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TriggerFunctionFilter', 'TriggerFunctionOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/uniqueConstraint.js

@@ -30,14 +30,18 @@ class UniqueConstraintModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('UniqueConstraint', 'uniqueConstraints', args.select, {
             where: args?.where,
-        }, 'UniqueConstraintFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UniqueConstraintFilter', 'UniqueConstraintOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/usageSnapshot.js

@@ -30,14 +30,18 @@ class UsageSnapshotModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('UsageSnapshot', 'usageSnapshots', args.select, {
             where: args?.where,
-        }, 'UsageSnapshotFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UsageSnapshotFilter', 'UsageSnapshotOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/user.js

@@ -30,14 +30,18 @@ class UserModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('User', 'users', args.select, {
             where: args?.where,
-        }, 'UserFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UserFilter', 'UserOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/userAuthModule.js

@@ -30,14 +30,18 @@ class UserAuthModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('UserAuthModule', 'userAuthModules', args.select, {
             where: args?.where,
-        }, 'UserAuthModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UserAuthModuleFilter', 'UserAuthModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/userConnectedAccount.js

@@ -30,14 +30,18 @@ class UserConnectedAccountModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('UserConnectedAccount', 'userConnectedAccounts', args.select, {
             where: args?.where,
-        }, 'UserConnectedAccountFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UserConnectedAccountFilter', 'UserConnectedAccountOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/usersModule.js

@@ -30,14 +30,18 @@ class UsersModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('UsersModule', 'usersModules', args.select, {
             where: args?.where,
-        }, 'UsersModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'UsersModuleFilter', 'UsersModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/view.js

@@ -30,14 +30,18 @@ class ViewModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('View', 'views', args.select, {
             where: args?.where,
-        }, 'ViewFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewFilter', 'ViewOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/viewGrant.js

@@ -30,14 +30,18 @@ class ViewGrantModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('ViewGrant', 'viewGrants', args.select, {
             where: args?.where,
-        }, 'ViewGrantFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewGrantFilter', 'ViewGrantOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/viewRule.js

@@ -30,14 +30,18 @@ class ViewRuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('ViewRule', 'viewRules', args.select, {
             where: args?.where,
-        }, 'ViewRuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewRuleFilter', 'ViewRuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/viewTable.js

@@ -30,14 +30,18 @@ class ViewTableModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('ViewTable', 'viewTables', args.select, {
             where: args?.where,
-        }, 'ViewTableFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ViewTableFilter', 'ViewTableOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/webauthnAuthModule.js

@@ -30,14 +30,18 @@ class WebauthnAuthModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('WebauthnAuthModule', 'webauthnAuthModules', args.select, {
             where: args?.where,
-        }, 'WebauthnAuthModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnAuthModuleFilter', 'WebauthnAuthModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/webauthnCredential.js

@@ -30,14 +30,18 @@ class WebauthnCredentialModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('WebauthnCredential', 'webauthnCredentials', args.select, {
             where: args?.where,
-        }, 'WebauthnCredentialFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnCredentialFilter', 'WebauthnCredentialOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/webauthnCredentialsModule.js

@@ -30,14 +30,18 @@ class WebauthnCredentialsModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('WebauthnCredentialsModule', 'webauthnCredentialsModules', args.select, {
             where: args?.where,
-        }, 'WebauthnCredentialsModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'WebauthnCredentialsModuleFilter', 'WebauthnCredentialsModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.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/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/public/orm/models/webauthnSetting.js

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