@constructive-io/sdk 0.21.6 → 0.21.8

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

@@ -15,12 +15,10 @@ export declare class AppLimitCreditModel {
     } & StrictSelect<S, AppLimitCreditSelect>): QueryBuilder<{
         appLimitCredits: ConnectionResult<InferSelectResult<AppLimitCreditWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitCreditSelect>(args: FindFirstArgs<S, AppLimitCreditFilter> & {
+    findFirst<S extends AppLimitCreditSelect>(args: FindFirstArgs<S, AppLimitCreditFilter, AppLimitCreditOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitCreditSelect>): QueryBuilder<{
-        appLimitCredits: {
-            nodes: InferSelectResult<AppLimitCreditWithRelations, S>[];
-        };
+        appLimitCredit: InferSelectResult<AppLimitCreditWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitCreditSelect>(args: {
         id: string;

package/public/orm/models/appLimitCredit.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitCreditCodeModel {
     } & StrictSelect<S, AppLimitCreditCodeSelect>): QueryBuilder<{
         appLimitCreditCodes: ConnectionResult<InferSelectResult<AppLimitCreditCodeWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitCreditCodeSelect>(args: FindFirstArgs<S, AppLimitCreditCodeFilter> & {
+    findFirst<S extends AppLimitCreditCodeSelect>(args: FindFirstArgs<S, AppLimitCreditCodeFilter, AppLimitCreditCodeOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitCreditCodeSelect>): QueryBuilder<{
-        appLimitCreditCodes: {
-            nodes: InferSelectResult<AppLimitCreditCodeWithRelations, S>[];
-        };
+        appLimitCreditCode: InferSelectResult<AppLimitCreditCodeWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitCreditCodeSelect>(args: {
         id: string;

package/public/orm/models/appLimitCreditCode.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitCreditCodeItemModel {
     } & StrictSelect<S, AppLimitCreditCodeItemSelect>): QueryBuilder<{
         appLimitCreditCodeItems: ConnectionResult<InferSelectResult<AppLimitCreditCodeItemWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitCreditCodeItemSelect>(args: FindFirstArgs<S, AppLimitCreditCodeItemFilter> & {
+    findFirst<S extends AppLimitCreditCodeItemSelect>(args: FindFirstArgs<S, AppLimitCreditCodeItemFilter, AppLimitCreditCodeItemOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitCreditCodeItemSelect>): QueryBuilder<{
-        appLimitCreditCodeItems: {
-            nodes: InferSelectResult<AppLimitCreditCodeItemWithRelations, S>[];
-        };
+        appLimitCreditCodeItem: InferSelectResult<AppLimitCreditCodeItemWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitCreditCodeItemSelect>(args: {
         id: string;

package/public/orm/models/appLimitCreditCodeItem.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitCreditRedemptionModel {
     } & StrictSelect<S, AppLimitCreditRedemptionSelect>): QueryBuilder<{
         appLimitCreditRedemptions: ConnectionResult<InferSelectResult<AppLimitCreditRedemptionWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitCreditRedemptionSelect>(args: FindFirstArgs<S, AppLimitCreditRedemptionFilter> & {
+    findFirst<S extends AppLimitCreditRedemptionSelect>(args: FindFirstArgs<S, AppLimitCreditRedemptionFilter, AppLimitCreditRedemptionOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitCreditRedemptionSelect>): QueryBuilder<{
-        appLimitCreditRedemptions: {
-            nodes: InferSelectResult<AppLimitCreditRedemptionWithRelations, S>[];
-        };
+        appLimitCreditRedemption: InferSelectResult<AppLimitCreditRedemptionWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitCreditRedemptionSelect>(args: {
         id: string;

package/public/orm/models/appLimitCreditRedemption.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitDefaultModel {
     } & StrictSelect<S, AppLimitDefaultSelect>): QueryBuilder<{
         appLimitDefaults: ConnectionResult<InferSelectResult<AppLimitDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitDefaultSelect>(args: FindFirstArgs<S, AppLimitDefaultFilter> & {
+    findFirst<S extends AppLimitDefaultSelect>(args: FindFirstArgs<S, AppLimitDefaultFilter, AppLimitDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitDefaultSelect>): QueryBuilder<{
-        appLimitDefaults: {
-            nodes: InferSelectResult<AppLimitDefaultWithRelations, S>[];
-        };
+        appLimitDefault: InferSelectResult<AppLimitDefaultWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitDefaultSelect>(args: {
         id: string;

package/public/orm/models/appLimitDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitEventModel {
     } & StrictSelect<S, AppLimitEventSelect>): QueryBuilder<{
         appLimitEvents: ConnectionResult<InferSelectResult<AppLimitEventWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitEventSelect>(args: FindFirstArgs<S, AppLimitEventFilter> & {
+    findFirst<S extends AppLimitEventSelect>(args: FindFirstArgs<S, AppLimitEventFilter, AppLimitEventOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitEventSelect>): QueryBuilder<{
-        appLimitEvents: {
-            nodes: InferSelectResult<AppLimitEventWithRelations, S>[];
-        };
+        appLimitEvent: InferSelectResult<AppLimitEventWithRelations, S> | null;
     }>;
     create<S extends AppLimitEventSelect>(args: CreateArgs<S, CreateAppLimitEventInput['appLimitEvent']> & {
         select: S;

package/public/orm/models/appLimitEvent.js

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

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

@@ -15,12 +15,10 @@ export declare class AppMembershipModel {
     } & StrictSelect<S, AppMembershipSelect>): QueryBuilder<{
         appMemberships: ConnectionResult<InferSelectResult<AppMembershipWithRelations, S>>;
     }>;
-    findFirst<S extends AppMembershipSelect>(args: FindFirstArgs<S, AppMembershipFilter> & {
+    findFirst<S extends AppMembershipSelect>(args: FindFirstArgs<S, AppMembershipFilter, AppMembershipOrderBy> & {
         select: S;
     } & StrictSelect<S, AppMembershipSelect>): QueryBuilder<{
-        appMemberships: {
-            nodes: InferSelectResult<AppMembershipWithRelations, S>[];
-        };
+        appMembership: InferSelectResult<AppMembershipWithRelations, S> | null;
     }>;
     findOne<S extends AppMembershipSelect>(args: {
         id: string;

package/public/orm/models/appMembership.js

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

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

@@ -15,12 +15,10 @@ export declare class AppMembershipDefaultModel {
     } & StrictSelect<S, AppMembershipDefaultSelect>): QueryBuilder<{
         appMembershipDefaults: ConnectionResult<InferSelectResult<AppMembershipDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends AppMembershipDefaultSelect>(args: FindFirstArgs<S, AppMembershipDefaultFilter> & {
+    findFirst<S extends AppMembershipDefaultSelect>(args: FindFirstArgs<S, AppMembershipDefaultFilter, AppMembershipDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, AppMembershipDefaultSelect>): QueryBuilder<{
-        appMembershipDefaults: {
-            nodes: InferSelectResult<AppMembershipDefaultWithRelations, S>[];
-        };
+        appMembershipDefault: InferSelectResult<AppMembershipDefaultWithRelations, S> | null;
     }>;
     findOne<S extends AppMembershipDefaultSelect>(args: {
         id: string;

package/public/orm/models/appMembershipDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class AppOwnerGrantModel {
     } & StrictSelect<S, AppOwnerGrantSelect>): QueryBuilder<{
         appOwnerGrants: ConnectionResult<InferSelectResult<AppOwnerGrantWithRelations, S>>;
     }>;
-    findFirst<S extends AppOwnerGrantSelect>(args: FindFirstArgs<S, AppOwnerGrantFilter> & {
+    findFirst<S extends AppOwnerGrantSelect>(args: FindFirstArgs<S, AppOwnerGrantFilter, AppOwnerGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, AppOwnerGrantSelect>): QueryBuilder<{
-        appOwnerGrants: {
-            nodes: InferSelectResult<AppOwnerGrantWithRelations, S>[];
-        };
+        appOwnerGrant: InferSelectResult<AppOwnerGrantWithRelations, S> | null;
     }>;
     findOne<S extends AppOwnerGrantSelect>(args: {
         id: string;

package/public/orm/models/appOwnerGrant.js

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

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

@@ -15,12 +15,10 @@ export declare class AppPermissionModel {
     } & StrictSelect<S, AppPermissionSelect>): QueryBuilder<{
         appPermissions: ConnectionResult<InferSelectResult<AppPermissionWithRelations, S>>;
     }>;
-    findFirst<S extends AppPermissionSelect>(args: FindFirstArgs<S, AppPermissionFilter> & {
+    findFirst<S extends AppPermissionSelect>(args: FindFirstArgs<S, AppPermissionFilter, AppPermissionOrderBy> & {
         select: S;
     } & StrictSelect<S, AppPermissionSelect>): QueryBuilder<{
-        appPermissions: {
-            nodes: InferSelectResult<AppPermissionWithRelations, S>[];
-        };
+        appPermission: InferSelectResult<AppPermissionWithRelations, S> | null;
     }>;
     findOne<S extends AppPermissionSelect>(args: {
         id: string;

package/public/orm/models/appPermission.js

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

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

@@ -15,12 +15,10 @@ export declare class AppPermissionDefaultModel {
     } & StrictSelect<S, AppPermissionDefaultSelect>): QueryBuilder<{
         appPermissionDefaults: ConnectionResult<InferSelectResult<AppPermissionDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends AppPermissionDefaultSelect>(args: FindFirstArgs<S, AppPermissionDefaultFilter> & {
+    findFirst<S extends AppPermissionDefaultSelect>(args: FindFirstArgs<S, AppPermissionDefaultFilter, AppPermissionDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, AppPermissionDefaultSelect>): QueryBuilder<{
-        appPermissionDefaults: {
-            nodes: InferSelectResult<AppPermissionDefaultWithRelations, S>[];
-        };
+        appPermissionDefault: InferSelectResult<AppPermissionDefaultWithRelations, S> | null;
     }>;
     findOne<S extends AppPermissionDefaultSelect>(args: {
         id: string;

package/public/orm/models/appPermissionDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class AppStepModel {
     } & StrictSelect<S, AppStepSelect>): QueryBuilder<{
         appSteps: ConnectionResult<InferSelectResult<AppStepWithRelations, S>>;
     }>;
-    findFirst<S extends AppStepSelect>(args: FindFirstArgs<S, AppStepFilter> & {
+    findFirst<S extends AppStepSelect>(args: FindFirstArgs<S, AppStepFilter, AppStepOrderBy> & {
         select: S;
     } & StrictSelect<S, AppStepSelect>): QueryBuilder<{
-        appSteps: {
-            nodes: InferSelectResult<AppStepWithRelations, S>[];
-        };
+        appStep: InferSelectResult<AppStepWithRelations, S> | null;
     }>;
     findOne<S extends AppStepSelect>(args: {
         id: string;

package/public/orm/models/appStep.js

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

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

@@ -15,12 +15,10 @@ export declare class AstMigrationModel {
     } & StrictSelect<S, AstMigrationSelect>): QueryBuilder<{
         astMigrations: ConnectionResult<InferSelectResult<AstMigrationWithRelations, S>>;
     }>;
-    findFirst<S extends AstMigrationSelect>(args: FindFirstArgs<S, AstMigrationFilter> & {
+    findFirst<S extends AstMigrationSelect>(args: FindFirstArgs<S, AstMigrationFilter, AstMigrationOrderBy> & {
         select: S;
     } & StrictSelect<S, AstMigrationSelect>): QueryBuilder<{
-        astMigrations: {
-            nodes: InferSelectResult<AstMigrationWithRelations, S>[];
-        };
+        astMigration: InferSelectResult<AstMigrationWithRelations, S> | null;
     }>;
     findOne<S extends AstMigrationSelect>(args: {
         id: number;

package/public/orm/models/astMigration.js

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

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

@@ -15,12 +15,10 @@ export declare class AuditLogModel {
     } & StrictSelect<S, AuditLogSelect>): QueryBuilder<{
         auditLogs: ConnectionResult<InferSelectResult<AuditLogWithRelations, S>>;
     }>;
-    findFirst<S extends AuditLogSelect>(args: FindFirstArgs<S, AuditLogFilter> & {
+    findFirst<S extends AuditLogSelect>(args: FindFirstArgs<S, AuditLogFilter, AuditLogOrderBy> & {
         select: S;
     } & StrictSelect<S, AuditLogSelect>): QueryBuilder<{
-        auditLogs: {
-            nodes: InferSelectResult<AuditLogWithRelations, S>[];
-        };
+        auditLog: InferSelectResult<AuditLogWithRelations, S> | null;
     }>;
     findOne<S extends AuditLogSelect>(args: {
         id: string;

package/public/orm/models/auditLog.js

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

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

@@ -15,12 +15,10 @@ export declare class BillingModuleModel {
     } & StrictSelect<S, BillingModuleSelect>): QueryBuilder<{
         billingModules: ConnectionResult<InferSelectResult<BillingModuleWithRelations, S>>;
     }>;
-    findFirst<S extends BillingModuleSelect>(args: FindFirstArgs<S, BillingModuleFilter> & {
+    findFirst<S extends BillingModuleSelect>(args: FindFirstArgs<S, BillingModuleFilter, BillingModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, BillingModuleSelect>): QueryBuilder<{
-        billingModules: {
-            nodes: InferSelectResult<BillingModuleWithRelations, S>[];
-        };
+        billingModule: InferSelectResult<BillingModuleWithRelations, S> | null;
     }>;
     findOne<S extends BillingModuleSelect>(args: {
         id: string;

package/public/orm/models/billingModule.js

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

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

@@ -15,12 +15,10 @@ export declare class BillingProviderModuleModel {
     } & StrictSelect<S, BillingProviderModuleSelect>): QueryBuilder<{
         billingProviderModules: ConnectionResult<InferSelectResult<BillingProviderModuleWithRelations, S>>;
     }>;
-    findFirst<S extends BillingProviderModuleSelect>(args: FindFirstArgs<S, BillingProviderModuleFilter> & {
+    findFirst<S extends BillingProviderModuleSelect>(args: FindFirstArgs<S, BillingProviderModuleFilter, BillingProviderModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, BillingProviderModuleSelect>): QueryBuilder<{
-        billingProviderModules: {
-            nodes: InferSelectResult<BillingProviderModuleWithRelations, S>[];
-        };
+        billingProviderModule: InferSelectResult<BillingProviderModuleWithRelations, S> | null;
     }>;
     findOne<S extends BillingProviderModuleSelect>(args: {
         id: string;

package/public/orm/models/billingProviderModule.js

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

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

@@ -15,12 +15,10 @@ export declare class BlueprintModel {
     } & StrictSelect<S, BlueprintSelect>): QueryBuilder<{
         blueprints: ConnectionResult<InferSelectResult<BlueprintWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintSelect>(args: FindFirstArgs<S, BlueprintFilter> & {
+    findFirst<S extends BlueprintSelect>(args: FindFirstArgs<S, BlueprintFilter, BlueprintOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintSelect>): QueryBuilder<{
-        blueprints: {
-            nodes: InferSelectResult<BlueprintWithRelations, S>[];
-        };
+        blueprint: InferSelectResult<BlueprintWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintSelect>(args: {
         id: string;