@constructive-io/react 0.19.5 → 0.19.7

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

@@ -27,14 +27,18 @@ export class SiteModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Site', 'sites', args.select, {
             where: args?.where,
-        }, 'SiteFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteFilter', 'SiteOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Site',
-            fieldName: 'sites',
+            fieldName: 'site',
             document,
             variables,
+            transform: (data) => ({
+                site: data.sites?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteMetadatumModel {
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
         siteMetadata: ConnectionResult<InferSelectResult<SiteMetadatumWithRelations, S>>;
     }>;
-    findFirst<S extends SiteMetadatumSelect>(args: FindFirstArgs<S, SiteMetadatumFilter> & {
+    findFirst<S extends SiteMetadatumSelect>(args: FindFirstArgs<S, SiteMetadatumFilter, SiteMetadatumOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
-        siteMetadata: {
-            nodes: InferSelectResult<SiteMetadatumWithRelations, S>[];
-        };
+        siteMetadatum: InferSelectResult<SiteMetadatumWithRelations, S> | null;
     }>;
     findOne<S extends SiteMetadatumSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SiteMetadatumModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteMetadatum', 'siteMetadata', args.select, {
             where: args?.where,
-        }, 'SiteMetadatumFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteMetadatumFilter', 'SiteMetadatumOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteMetadatum',
-            fieldName: 'siteMetadata',
+            fieldName: 'siteMetadatum',
             document,
             variables,
+            transform: (data) => ({
+                siteMetadatum: data.siteMetadata?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteModuleModel {
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
         siteModules: ConnectionResult<InferSelectResult<SiteModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SiteModuleSelect>(args: FindFirstArgs<S, SiteModuleFilter> & {
+    findFirst<S extends SiteModuleSelect>(args: FindFirstArgs<S, SiteModuleFilter, SiteModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
-        siteModules: {
-            nodes: InferSelectResult<SiteModuleWithRelations, S>[];
-        };
+        siteModule: InferSelectResult<SiteModuleWithRelations, S> | null;
     }>;
     findOne<S extends SiteModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SiteModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteModule', 'siteModules', args.select, {
             where: args?.where,
-        }, 'SiteModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteModuleFilter', 'SiteModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteModule',
-            fieldName: 'siteModules',
+            fieldName: 'siteModule',
             document,
             variables,
+            transform: (data) => ({
+                siteModule: data.siteModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteThemeModel {
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
         siteThemes: ConnectionResult<InferSelectResult<SiteThemeWithRelations, S>>;
     }>;
-    findFirst<S extends SiteThemeSelect>(args: FindFirstArgs<S, SiteThemeFilter> & {
+    findFirst<S extends SiteThemeSelect>(args: FindFirstArgs<S, SiteThemeFilter, SiteThemeOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
-        siteThemes: {
-            nodes: InferSelectResult<SiteThemeWithRelations, S>[];
-        };
+        siteTheme: InferSelectResult<SiteThemeWithRelations, S> | null;
     }>;
     findOne<S extends SiteThemeSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SiteThemeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteTheme', 'siteThemes', args.select, {
             where: args?.where,
-        }, 'SiteThemeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteThemeFilter', 'SiteThemeOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteTheme',
-            fieldName: 'siteThemes',
+            fieldName: 'siteTheme',
             document,
             variables,
+            transform: (data) => ({
+                siteTheme: data.siteThemes?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SpatialRelationModel {
     } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
         spatialRelations: ConnectionResult<InferSelectResult<SpatialRelationWithRelations, S>>;
     }>;
-    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter> & {
+    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter, SpatialRelationOrderBy> & {
         select: S;
     } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
-        spatialRelations: {
-            nodes: InferSelectResult<SpatialRelationWithRelations, S>[];
-        };
+        spatialRelation: InferSelectResult<SpatialRelationWithRelations, S> | null;
     }>;
     findOne<S extends SpatialRelationSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SpatialRelationModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SpatialRelation', 'spatialRelations', args.select, {
             where: args?.where,
-        }, 'SpatialRelationFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SpatialRelationFilter', 'SpatialRelationOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SpatialRelation',
-            fieldName: 'spatialRelations',
+            fieldName: 'spatialRelation',
             document,
             variables,
+            transform: (data) => ({
+                spatialRelation: data.spatialRelations?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SqlActionModel {
     } & StrictSelect<S, SqlActionSelect>): QueryBuilder<{
         sqlActions: ConnectionResult<InferSelectResult<SqlActionWithRelations, S>>;
     }>;
-    findFirst<S extends SqlActionSelect>(args: FindFirstArgs<S, SqlActionFilter> & {
+    findFirst<S extends SqlActionSelect>(args: FindFirstArgs<S, SqlActionFilter, SqlActionOrderBy> & {
         select: S;
     } & StrictSelect<S, SqlActionSelect>): QueryBuilder<{
-        sqlActions: {
-            nodes: InferSelectResult<SqlActionWithRelations, S>[];
-        };
+        sqlAction: InferSelectResult<SqlActionWithRelations, S> | null;
     }>;
     findOne<S extends SqlActionSelect>(args: {
         id: number;

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

@@ -27,14 +27,18 @@ export class SqlActionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SqlAction', 'sqlActions', args.select, {
             where: args?.where,
-        }, 'SqlActionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SqlActionFilter', 'SqlActionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SqlAction',
-            fieldName: 'sqlActions',
+            fieldName: 'sqlAction',
             document,
             variables,
+            transform: (data) => ({
+                sqlAction: data.sqlActions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class StorageModuleModel {
     } & StrictSelect<S, StorageModuleSelect>): QueryBuilder<{
         storageModules: ConnectionResult<InferSelectResult<StorageModuleWithRelations, S>>;
     }>;
-    findFirst<S extends StorageModuleSelect>(args: FindFirstArgs<S, StorageModuleFilter> & {
+    findFirst<S extends StorageModuleSelect>(args: FindFirstArgs<S, StorageModuleFilter, StorageModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, StorageModuleSelect>): QueryBuilder<{
-        storageModules: {
-            nodes: InferSelectResult<StorageModuleWithRelations, S>[];
-        };
+        storageModule: InferSelectResult<StorageModuleWithRelations, S> | null;
     }>;
     findOne<S extends StorageModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class StorageModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('StorageModule', 'storageModules', args.select, {
             where: args?.where,
-        }, 'StorageModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'StorageModuleFilter', 'StorageModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'StorageModule',
-            fieldName: 'storageModules',
+            fieldName: 'storageModule',
             document,
             variables,
+            transform: (data) => ({
+                storageModule: data.storageModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class StoreModel {
     } & StrictSelect<S, StoreSelect>): QueryBuilder<{
         stores: ConnectionResult<InferSelectResult<StoreWithRelations, S>>;
     }>;
-    findFirst<S extends StoreSelect>(args: FindFirstArgs<S, StoreFilter> & {
+    findFirst<S extends StoreSelect>(args: FindFirstArgs<S, StoreFilter, StoreOrderBy> & {
         select: S;
     } & StrictSelect<S, StoreSelect>): QueryBuilder<{
-        stores: {
-            nodes: InferSelectResult<StoreWithRelations, S>[];
-        };
+        store: InferSelectResult<StoreWithRelations, S> | null;
     }>;
     findOne<S extends StoreSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class StoreModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Store', 'stores', args.select, {
             where: args?.where,
-        }, 'StoreFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'StoreFilter', 'StoreOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Store',
-            fieldName: 'stores',
+            fieldName: 'store',
             document,
             variables,
+            transform: (data) => ({
+                store: data.stores?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class TableModel {
     } & StrictSelect<S, TableSelect>): QueryBuilder<{
         tables: ConnectionResult<InferSelectResult<TableWithRelations, S>>;
     }>;
-    findFirst<S extends TableSelect>(args: FindFirstArgs<S, TableFilter> & {
+    findFirst<S extends TableSelect>(args: FindFirstArgs<S, TableFilter, TableOrderBy> & {
         select: S;
     } & StrictSelect<S, TableSelect>): QueryBuilder<{
-        tables: {
-            nodes: InferSelectResult<TableWithRelations, S>[];
-        };
+        table: InferSelectResult<TableWithRelations, S> | null;
     }>;
     findOne<S extends TableSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class TableModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Table', 'tables', args.select, {
             where: args?.where,
-        }, 'TableFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TableFilter', 'TableOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Table',
-            fieldName: 'tables',
+            fieldName: 'table',
             document,
             variables,
+            transform: (data) => ({
+                table: data.tables?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class TableGrantModel {
     } & StrictSelect<S, TableGrantSelect>): QueryBuilder<{
         tableGrants: ConnectionResult<InferSelectResult<TableGrantWithRelations, S>>;
     }>;
-    findFirst<S extends TableGrantSelect>(args: FindFirstArgs<S, TableGrantFilter> & {
+    findFirst<S extends TableGrantSelect>(args: FindFirstArgs<S, TableGrantFilter, TableGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, TableGrantSelect>): QueryBuilder<{
-        tableGrants: {
-            nodes: InferSelectResult<TableGrantWithRelations, S>[];
-        };
+        tableGrant: InferSelectResult<TableGrantWithRelations, S> | null;
     }>;
     findOne<S extends TableGrantSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class TableGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('TableGrant', 'tableGrants', args.select, {
             where: args?.where,
-        }, 'TableGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TableGrantFilter', 'TableGrantOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'TableGrant',
-            fieldName: 'tableGrants',
+            fieldName: 'tableGrant',
             document,
             variables,
+            transform: (data) => ({
+                tableGrant: data.tableGrants?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -27,14 +27,18 @@ export class TriggerModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Trigger', 'triggers', args.select, {
             where: args?.where,
-        }, 'TriggerFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TriggerFilter', 'TriggerOrderBy', connectionFieldsMap);
         return new 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/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) {