@constructive-io/react 0.19.5 → 0.19.7

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

@@ -15,12 +15,10 @@ export declare class FieldModel {
     } & StrictSelect<S, FieldSelect>): QueryBuilder<{
         fields: ConnectionResult<InferSelectResult<FieldWithRelations, S>>;
     }>;
-    findFirst<S extends FieldSelect>(args: FindFirstArgs<S, FieldFilter> & {
+    findFirst<S extends FieldSelect>(args: FindFirstArgs<S, FieldFilter, FieldOrderBy> & {
         select: S;
     } & StrictSelect<S, FieldSelect>): QueryBuilder<{
-        fields: {
-            nodes: InferSelectResult<FieldWithRelations, S>[];
-        };
+        field: InferSelectResult<FieldWithRelations, S> | null;
     }>;
     findOne<S extends FieldSelect>(args: {
         id: string;

package/public/orm/models/field.js

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

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

@@ -15,12 +15,10 @@ export declare class ForeignKeyConstraintModel {
     } & StrictSelect<S, ForeignKeyConstraintSelect>): QueryBuilder<{
         foreignKeyConstraints: ConnectionResult<InferSelectResult<ForeignKeyConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends ForeignKeyConstraintSelect>(args: FindFirstArgs<S, ForeignKeyConstraintFilter> & {
+    findFirst<S extends ForeignKeyConstraintSelect>(args: FindFirstArgs<S, ForeignKeyConstraintFilter, ForeignKeyConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, ForeignKeyConstraintSelect>): QueryBuilder<{
-        foreignKeyConstraints: {
-            nodes: InferSelectResult<ForeignKeyConstraintWithRelations, S>[];
-        };
+        foreignKeyConstraint: InferSelectResult<ForeignKeyConstraintWithRelations, S> | null;
     }>;
     findOne<S extends ForeignKeyConstraintSelect>(args: {
         id: string;

package/public/orm/models/foreignKeyConstraint.js

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

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

@@ -15,12 +15,10 @@ export declare class FullTextSearchModel {
     } & StrictSelect<S, FullTextSearchSelect>): QueryBuilder<{
         fullTextSearches: ConnectionResult<InferSelectResult<FullTextSearchWithRelations, S>>;
     }>;
-    findFirst<S extends FullTextSearchSelect>(args: FindFirstArgs<S, FullTextSearchFilter> & {
+    findFirst<S extends FullTextSearchSelect>(args: FindFirstArgs<S, FullTextSearchFilter, FullTextSearchOrderBy> & {
         select: S;
     } & StrictSelect<S, FullTextSearchSelect>): QueryBuilder<{
-        fullTextSearches: {
-            nodes: InferSelectResult<FullTextSearchWithRelations, S>[];
-        };
+        fullTextSearch: InferSelectResult<FullTextSearchWithRelations, S> | null;
     }>;
     findOne<S extends FullTextSearchSelect>(args: {
         id: string;

package/public/orm/models/fullTextSearch.js

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

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

@@ -15,12 +15,10 @@ export declare class FunctionModel {
     } & StrictSelect<S, FunctionSelect>): QueryBuilder<{
         functions: ConnectionResult<InferSelectResult<FunctionWithRelations, S>>;
     }>;
-    findFirst<S extends FunctionSelect>(args: FindFirstArgs<S, FunctionFilter> & {
+    findFirst<S extends FunctionSelect>(args: FindFirstArgs<S, FunctionFilter, FunctionOrderBy> & {
         select: S;
     } & StrictSelect<S, FunctionSelect>): QueryBuilder<{
-        functions: {
-            nodes: InferSelectResult<FunctionWithRelations, S>[];
-        };
+        function: InferSelectResult<FunctionWithRelations, S> | null;
     }>;
     findOne<S extends FunctionSelect>(args: {
         id: string;

package/public/orm/models/function.js

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

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

@@ -15,12 +15,10 @@ export declare class GetAllRecordModel {
     } & StrictSelect<S, GetAllRecordSelect>): QueryBuilder<{
         getAll: ConnectionResult<InferSelectResult<GetAllRecordWithRelations, S>>;
     }>;
-    findFirst<S extends GetAllRecordSelect>(args: FindFirstArgs<S, GetAllRecordFilter> & {
+    findFirst<S extends GetAllRecordSelect>(args: FindFirstArgs<S, GetAllRecordFilter, GetAllRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, GetAllRecordSelect>): QueryBuilder<{
-        getAll: {
-            nodes: InferSelectResult<GetAllRecordWithRelations, S>[];
-        };
+        getAllRecord: InferSelectResult<GetAllRecordWithRelations, S> | null;
     }>;
     create<S extends GetAllRecordSelect>(args: CreateArgs<S, CreateGetAllRecordInput['getAllRecord']> & {
         select: S;

package/public/orm/models/getAllRecord.js

@@ -30,14 +30,18 @@ class GetAllRecordModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('GetAllRecord', 'getAll', args.select, {
             where: args?.where,
-        }, 'GetAllRecordFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'GetAllRecordFilter', 'GetAllRecordsOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'GetAllRecord',
-            fieldName: 'getAll',
+            fieldName: 'getAllRecord',
             document,
             variables,
+            transform: (data) => ({
+                getAllRecord: data.getAll?.nodes?.[0] ?? null,
+            }),
         });
     }
     create(args) {

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

@@ -15,12 +15,10 @@ export declare class HierarchyModuleModel {
     } & StrictSelect<S, HierarchyModuleSelect>): QueryBuilder<{
         hierarchyModules: ConnectionResult<InferSelectResult<HierarchyModuleWithRelations, S>>;
     }>;
-    findFirst<S extends HierarchyModuleSelect>(args: FindFirstArgs<S, HierarchyModuleFilter> & {
+    findFirst<S extends HierarchyModuleSelect>(args: FindFirstArgs<S, HierarchyModuleFilter, HierarchyModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, HierarchyModuleSelect>): QueryBuilder<{
-        hierarchyModules: {
-            nodes: InferSelectResult<HierarchyModuleWithRelations, S>[];
-        };
+        hierarchyModule: InferSelectResult<HierarchyModuleWithRelations, S> | null;
     }>;
     findOne<S extends HierarchyModuleSelect>(args: {
         id: string;

package/public/orm/models/hierarchyModule.js

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

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

@@ -15,12 +15,10 @@ export declare class IdentityProviderModel {
     } & StrictSelect<S, IdentityProviderSelect>): QueryBuilder<{
         identityProviders: ConnectionResult<InferSelectResult<IdentityProviderWithRelations, S>>;
     }>;
-    findFirst<S extends IdentityProviderSelect>(args: FindFirstArgs<S, IdentityProviderFilter> & {
+    findFirst<S extends IdentityProviderSelect>(args: FindFirstArgs<S, IdentityProviderFilter, IdentityProviderOrderBy> & {
         select: S;
     } & StrictSelect<S, IdentityProviderSelect>): QueryBuilder<{
-        identityProviders: {
-            nodes: InferSelectResult<IdentityProviderWithRelations, S>[];
-        };
+        identityProvider: InferSelectResult<IdentityProviderWithRelations, S> | null;
     }>;
     create<S extends IdentityProviderSelect>(args: CreateArgs<S, CreateIdentityProviderInput['identityProvider']> & {
         select: S;

package/public/orm/models/identityProvider.js

@@ -30,14 +30,18 @@ class IdentityProviderModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('IdentityProvider', 'identityProviders', args.select, {
             where: args?.where,
-        }, 'IdentityProviderFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'IdentityProviderFilter', 'IdentityProviderOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'IdentityProvider',
-            fieldName: 'identityProviders',
+            fieldName: 'identityProvider',
             document,
             variables,
+            transform: (data) => ({
+                identityProvider: data.identityProviders?.nodes?.[0] ?? null,
+            }),
         });
     }
     create(args) {

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

@@ -15,12 +15,10 @@ export declare class IdentityProvidersModuleModel {
     } & StrictSelect<S, IdentityProvidersModuleSelect>): QueryBuilder<{
         identityProvidersModules: ConnectionResult<InferSelectResult<IdentityProvidersModuleWithRelations, S>>;
     }>;
-    findFirst<S extends IdentityProvidersModuleSelect>(args: FindFirstArgs<S, IdentityProvidersModuleFilter> & {
+    findFirst<S extends IdentityProvidersModuleSelect>(args: FindFirstArgs<S, IdentityProvidersModuleFilter, IdentityProvidersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, IdentityProvidersModuleSelect>): QueryBuilder<{
-        identityProvidersModules: {
-            nodes: InferSelectResult<IdentityProvidersModuleWithRelations, S>[];
-        };
+        identityProvidersModule: InferSelectResult<IdentityProvidersModuleWithRelations, S> | null;
     }>;
     findOne<S extends IdentityProvidersModuleSelect>(args: {
         id: string;

package/public/orm/models/identityProvidersModule.js

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

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

@@ -15,12 +15,10 @@ export declare class IndexModel {
     } & StrictSelect<S, IndexSelect>): QueryBuilder<{
         indices: ConnectionResult<InferSelectResult<IndexWithRelations, S>>;
     }>;
-    findFirst<S extends IndexSelect>(args: FindFirstArgs<S, IndexFilter> & {
+    findFirst<S extends IndexSelect>(args: FindFirstArgs<S, IndexFilter, IndexOrderBy> & {
         select: S;
     } & StrictSelect<S, IndexSelect>): QueryBuilder<{
-        indices: {
-            nodes: InferSelectResult<IndexWithRelations, S>[];
-        };
+        index: InferSelectResult<IndexWithRelations, S> | null;
     }>;
     findOne<S extends IndexSelect>(args: {
         id: string;

package/public/orm/models/indexModel.js

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

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

@@ -15,12 +15,10 @@ export declare class InvitesModuleModel {
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
         invitesModules: ConnectionResult<InferSelectResult<InvitesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter> & {
+    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter, InvitesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
-        invitesModules: {
-            nodes: InferSelectResult<InvitesModuleWithRelations, S>[];
-        };
+        invitesModule: InferSelectResult<InvitesModuleWithRelations, S> | null;
     }>;
     findOne<S extends InvitesModuleSelect>(args: {
         id: string;

package/public/orm/models/invitesModule.js

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

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

@@ -15,12 +15,10 @@ export declare class LevelsModuleModel {
     } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
         levelsModules: ConnectionResult<InferSelectResult<LevelsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends LevelsModuleSelect>(args: FindFirstArgs<S, LevelsModuleFilter> & {
+    findFirst<S extends LevelsModuleSelect>(args: FindFirstArgs<S, LevelsModuleFilter, LevelsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
-        levelsModules: {
-            nodes: InferSelectResult<LevelsModuleWithRelations, S>[];
-        };
+        levelsModule: InferSelectResult<LevelsModuleWithRelations, S> | null;
     }>;
     findOne<S extends LevelsModuleSelect>(args: {
         id: string;

package/public/orm/models/levelsModule.js

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

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

@@ -15,12 +15,10 @@ export declare class LimitsModuleModel {
     } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
         limitsModules: ConnectionResult<InferSelectResult<LimitsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends LimitsModuleSelect>(args: FindFirstArgs<S, LimitsModuleFilter> & {
+    findFirst<S extends LimitsModuleSelect>(args: FindFirstArgs<S, LimitsModuleFilter, LimitsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
-        limitsModules: {
-            nodes: InferSelectResult<LimitsModuleWithRelations, S>[];
-        };
+        limitsModule: InferSelectResult<LimitsModuleWithRelations, S> | null;
     }>;
     findOne<S extends LimitsModuleSelect>(args: {
         id: string;

package/public/orm/models/limitsModule.js

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

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

@@ -15,12 +15,10 @@ export declare class MembershipTypeModel {
     } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
         membershipTypes: ConnectionResult<InferSelectResult<MembershipTypeWithRelations, S>>;
     }>;
-    findFirst<S extends MembershipTypeSelect>(args: FindFirstArgs<S, MembershipTypeFilter> & {
+    findFirst<S extends MembershipTypeSelect>(args: FindFirstArgs<S, MembershipTypeFilter, MembershipTypeOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
-        membershipTypes: {
-            nodes: InferSelectResult<MembershipTypeWithRelations, S>[];
-        };
+        membershipType: InferSelectResult<MembershipTypeWithRelations, S> | null;
     }>;
     findOne<S extends MembershipTypeSelect>(args: {
         id: number;

package/public/orm/models/membershipType.js

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

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

@@ -15,12 +15,10 @@ export declare class MembershipTypesModuleModel {
     } & StrictSelect<S, MembershipTypesModuleSelect>): QueryBuilder<{
         membershipTypesModules: ConnectionResult<InferSelectResult<MembershipTypesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends MembershipTypesModuleSelect>(args: FindFirstArgs<S, MembershipTypesModuleFilter> & {
+    findFirst<S extends MembershipTypesModuleSelect>(args: FindFirstArgs<S, MembershipTypesModuleFilter, MembershipTypesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipTypesModuleSelect>): QueryBuilder<{
-        membershipTypesModules: {
-            nodes: InferSelectResult<MembershipTypesModuleWithRelations, S>[];
-        };
+        membershipTypesModule: InferSelectResult<MembershipTypesModuleWithRelations, S> | null;
     }>;
     findOne<S extends MembershipTypesModuleSelect>(args: {
         id: string;

package/public/orm/models/membershipTypesModule.js

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

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

@@ -15,12 +15,10 @@ export declare class MembershipsModuleModel {
     } & StrictSelect<S, MembershipsModuleSelect>): QueryBuilder<{
         membershipsModules: ConnectionResult<InferSelectResult<MembershipsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends MembershipsModuleSelect>(args: FindFirstArgs<S, MembershipsModuleFilter> & {
+    findFirst<S extends MembershipsModuleSelect>(args: FindFirstArgs<S, MembershipsModuleFilter, MembershipsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipsModuleSelect>): QueryBuilder<{
-        membershipsModules: {
-            nodes: InferSelectResult<MembershipsModuleWithRelations, S>[];
-        };
+        membershipsModule: InferSelectResult<MembershipsModuleWithRelations, S> | null;
     }>;
     findOne<S extends MembershipsModuleSelect>(args: {
         id: string;

package/public/orm/models/membershipsModule.js

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

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

@@ -15,12 +15,10 @@ export declare class MigrateFileModel {
     } & StrictSelect<S, MigrateFileSelect>): QueryBuilder<{
         migrateFiles: ConnectionResult<InferSelectResult<MigrateFileWithRelations, S>>;
     }>;
-    findFirst<S extends MigrateFileSelect>(args: FindFirstArgs<S, MigrateFileFilter> & {
+    findFirst<S extends MigrateFileSelect>(args: FindFirstArgs<S, MigrateFileFilter, MigrateFileOrderBy> & {
         select: S;
     } & StrictSelect<S, MigrateFileSelect>): QueryBuilder<{
-        migrateFiles: {
-            nodes: InferSelectResult<MigrateFileWithRelations, S>[];
-        };
+        migrateFile: InferSelectResult<MigrateFileWithRelations, S> | null;
     }>;
     findOne<S extends MigrateFileSelect>(args: {
         id: string;

package/public/orm/models/migrateFile.js

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

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

@@ -15,12 +15,10 @@ export declare class NodeTypeRegistryModel {
     } & StrictSelect<S, NodeTypeRegistrySelect>): QueryBuilder<{
         nodeTypeRegistries: ConnectionResult<InferSelectResult<NodeTypeRegistryWithRelations, S>>;
     }>;
-    findFirst<S extends NodeTypeRegistrySelect>(args: FindFirstArgs<S, NodeTypeRegistryFilter> & {
+    findFirst<S extends NodeTypeRegistrySelect>(args: FindFirstArgs<S, NodeTypeRegistryFilter, NodeTypeRegistryOrderBy> & {
         select: S;
     } & StrictSelect<S, NodeTypeRegistrySelect>): QueryBuilder<{
-        nodeTypeRegistries: {
-            nodes: InferSelectResult<NodeTypeRegistryWithRelations, S>[];
-        };
+        nodeTypeRegistry: InferSelectResult<NodeTypeRegistryWithRelations, S> | null;
     }>;
     findOne<S extends NodeTypeRegistrySelect>(args: {
         name: string;