@constructive-sdk/cli 0.21.6 → 0.21.8

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

@@ -27,14 +27,18 @@ export class AppMembershipDefaultModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppMembershipDefault', 'appMembershipDefaults', args.select, {
             where: args?.where,
-        }, 'AppMembershipDefaultFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppMembershipDefaultFilter', 'AppMembershipDefaultOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appOwnerGrant.js

@@ -27,14 +27,18 @@ export class AppOwnerGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppOwnerGrant', 'appOwnerGrants', args.select, {
             where: args?.where,
-        }, 'AppOwnerGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppOwnerGrantFilter', 'AppOwnerGrantOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appPermission.js

@@ -27,14 +27,18 @@ export class AppPermissionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppPermission', 'appPermissions', args.select, {
             where: args?.where,
-        }, 'AppPermissionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppPermissionFilter', 'AppPermissionOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appPermissionDefault.js

@@ -27,14 +27,18 @@ export class AppPermissionDefaultModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppPermissionDefault', 'appPermissionDefaults', args.select, {
             where: args?.where,
-        }, 'AppPermissionDefaultFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppPermissionDefaultFilter', 'AppPermissionDefaultOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appStep.js

@@ -27,14 +27,18 @@ export class AppStepModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppStep', 'appSteps', args.select, {
             where: args?.where,
-        }, 'AppStepFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppStepFilter', 'AppStepOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/astMigration.js

@@ -27,14 +27,18 @@ export class AstMigrationModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AstMigration', 'astMigrations', args.select, {
             where: args?.where,
-        }, 'AstMigrationFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AstMigrationFilter', 'AstMigrationOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/auditLog.js

@@ -27,14 +27,18 @@ export class AuditLogModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AuditLog', 'auditLogs', args.select, {
             where: args?.where,
-        }, 'AuditLogFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AuditLogFilter', 'AuditLogOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/billingModule.js

@@ -27,14 +27,18 @@ export class BillingModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('BillingModule', 'billingModules', args.select, {
             where: args?.where,
-        }, 'BillingModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BillingModuleFilter', 'BillingModuleOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/billingProviderModule.js

@@ -27,14 +27,18 @@ export class BillingProviderModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('BillingProviderModule', 'billingProviderModules', args.select, {
             where: args?.where,
-        }, 'BillingProviderModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BillingProviderModuleFilter', 'BillingProviderModuleOrderBy', connectionFieldsMap);
         return new 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/esm/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;

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

@@ -27,14 +27,18 @@ export class BlueprintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Blueprint', 'blueprints', args.select, {
             where: args?.where,
-        }, 'BlueprintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintFilter', 'BlueprintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Blueprint',
-            fieldName: 'blueprints',
+            fieldName: 'blueprint',
             document,
             variables,
+            transform: (data) => ({
+                blueprint: data.blueprints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BlueprintConstructionModel {
     } & StrictSelect<S, BlueprintConstructionSelect>): QueryBuilder<{
         blueprintConstructions: ConnectionResult<InferSelectResult<BlueprintConstructionWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintConstructionSelect>(args: FindFirstArgs<S, BlueprintConstructionFilter> & {
+    findFirst<S extends BlueprintConstructionSelect>(args: FindFirstArgs<S, BlueprintConstructionFilter, BlueprintConstructionOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintConstructionSelect>): QueryBuilder<{
-        blueprintConstructions: {
-            nodes: InferSelectResult<BlueprintConstructionWithRelations, S>[];
-        };
+        blueprintConstruction: InferSelectResult<BlueprintConstructionWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintConstructionSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class BlueprintConstructionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('BlueprintConstruction', 'blueprintConstructions', args.select, {
             where: args?.where,
-        }, 'BlueprintConstructionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintConstructionFilter', 'BlueprintConstructionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BlueprintConstruction',
-            fieldName: 'blueprintConstructions',
+            fieldName: 'blueprintConstruction',
             document,
             variables,
+            transform: (data) => ({
+                blueprintConstruction: data.blueprintConstructions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BlueprintTemplateModel {
     } & StrictSelect<S, BlueprintTemplateSelect>): QueryBuilder<{
         blueprintTemplates: ConnectionResult<InferSelectResult<BlueprintTemplateWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintTemplateSelect>(args: FindFirstArgs<S, BlueprintTemplateFilter> & {
+    findFirst<S extends BlueprintTemplateSelect>(args: FindFirstArgs<S, BlueprintTemplateFilter, BlueprintTemplateOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintTemplateSelect>): QueryBuilder<{
-        blueprintTemplates: {
-            nodes: InferSelectResult<BlueprintTemplateWithRelations, S>[];
-        };
+        blueprintTemplate: InferSelectResult<BlueprintTemplateWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintTemplateSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class BlueprintTemplateModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('BlueprintTemplate', 'blueprintTemplates', args.select, {
             where: args?.where,
-        }, 'BlueprintTemplateFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintTemplateFilter', 'BlueprintTemplateOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BlueprintTemplate',
-            fieldName: 'blueprintTemplates',
+            fieldName: 'blueprintTemplate',
             document,
             variables,
+            transform: (data) => ({
+                blueprintTemplate: data.blueprintTemplates?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CheckConstraintModel {
     } & StrictSelect<S, CheckConstraintSelect>): QueryBuilder<{
         checkConstraints: ConnectionResult<InferSelectResult<CheckConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends CheckConstraintSelect>(args: FindFirstArgs<S, CheckConstraintFilter> & {
+    findFirst<S extends CheckConstraintSelect>(args: FindFirstArgs<S, CheckConstraintFilter, CheckConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, CheckConstraintSelect>): QueryBuilder<{
-        checkConstraints: {
-            nodes: InferSelectResult<CheckConstraintWithRelations, S>[];
-        };
+        checkConstraint: InferSelectResult<CheckConstraintWithRelations, S> | null;
     }>;
     findOne<S extends CheckConstraintSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CheckConstraintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CheckConstraint', 'checkConstraints', args.select, {
             where: args?.where,
-        }, 'CheckConstraintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CheckConstraintFilter', 'CheckConstraintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CheckConstraint',
-            fieldName: 'checkConstraints',
+            fieldName: 'checkConstraint',
             document,
             variables,
+            transform: (data) => ({
+                checkConstraint: data.checkConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CommitModel {
     } & StrictSelect<S, CommitSelect>): QueryBuilder<{
         commits: ConnectionResult<InferSelectResult<CommitWithRelations, S>>;
     }>;
-    findFirst<S extends CommitSelect>(args: FindFirstArgs<S, CommitFilter> & {
+    findFirst<S extends CommitSelect>(args: FindFirstArgs<S, CommitFilter, CommitOrderBy> & {
         select: S;
     } & StrictSelect<S, CommitSelect>): QueryBuilder<{
-        commits: {
-            nodes: InferSelectResult<CommitWithRelations, S>[];
-        };
+        commit: InferSelectResult<CommitWithRelations, S> | null;
     }>;
     findOne<S extends CommitSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CommitModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Commit', 'commits', args.select, {
             where: args?.where,
-        }, 'CommitFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CommitFilter', 'CommitOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Commit',
-            fieldName: 'commits',
+            fieldName: 'commit',
             document,
             variables,
+            transform: (data) => ({
+                commit: data.commits?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class ConnectedAccountsModuleModel {
     } & StrictSelect<S, ConnectedAccountsModuleSelect>): QueryBuilder<{
         connectedAccountsModules: ConnectionResult<InferSelectResult<ConnectedAccountsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends ConnectedAccountsModuleSelect>(args: FindFirstArgs<S, ConnectedAccountsModuleFilter> & {
+    findFirst<S extends ConnectedAccountsModuleSelect>(args: FindFirstArgs<S, ConnectedAccountsModuleFilter, ConnectedAccountsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ConnectedAccountsModuleSelect>): QueryBuilder<{
-        connectedAccountsModules: {
-            nodes: InferSelectResult<ConnectedAccountsModuleWithRelations, S>[];
-        };
+        connectedAccountsModule: InferSelectResult<ConnectedAccountsModuleWithRelations, S> | null;
     }>;
     findOne<S extends ConnectedAccountsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class ConnectedAccountsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ConnectedAccountsModule', 'connectedAccountsModules', args.select, {
             where: args?.where,
-        }, 'ConnectedAccountsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ConnectedAccountsModuleFilter', 'ConnectedAccountsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ConnectedAccountsModule',
-            fieldName: 'connectedAccountsModules',
+            fieldName: 'connectedAccountsModule',
             document,
             variables,
+            transform: (data) => ({
+                connectedAccountsModule: data.connectedAccountsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CorsSettingModel {
     } & StrictSelect<S, CorsSettingSelect>): QueryBuilder<{
         corsSettings: ConnectionResult<InferSelectResult<CorsSettingWithRelations, S>>;
     }>;
-    findFirst<S extends CorsSettingSelect>(args: FindFirstArgs<S, CorsSettingFilter> & {
+    findFirst<S extends CorsSettingSelect>(args: FindFirstArgs<S, CorsSettingFilter, CorsSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, CorsSettingSelect>): QueryBuilder<{
-        corsSettings: {
-            nodes: InferSelectResult<CorsSettingWithRelations, S>[];
-        };
+        corsSetting: InferSelectResult<CorsSettingWithRelations, S> | null;
     }>;
     findOne<S extends CorsSettingSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CorsSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CorsSetting', 'corsSettings', args.select, {
             where: args?.where,
-        }, 'CorsSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CorsSettingFilter', 'CorsSettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CorsSetting',
-            fieldName: 'corsSettings',
+            fieldName: 'corsSetting',
             document,
             variables,
+            transform: (data) => ({
+                corsSetting: data.corsSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CryptoAddressModel {
     } & StrictSelect<S, CryptoAddressSelect>): QueryBuilder<{
         cryptoAddresses: ConnectionResult<InferSelectResult<CryptoAddressWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAddressSelect>(args: FindFirstArgs<S, CryptoAddressFilter> & {
+    findFirst<S extends CryptoAddressSelect>(args: FindFirstArgs<S, CryptoAddressFilter, CryptoAddressOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAddressSelect>): QueryBuilder<{
-        cryptoAddresses: {
-            nodes: InferSelectResult<CryptoAddressWithRelations, S>[];
-        };
+        cryptoAddress: InferSelectResult<CryptoAddressWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAddressSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CryptoAddressModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CryptoAddress', 'cryptoAddresses', args.select, {
             where: args?.where,
-        }, 'CryptoAddressFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAddressFilter', 'CryptoAddressOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAddress',
-            fieldName: 'cryptoAddresses',
+            fieldName: 'cryptoAddress',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAddress: data.cryptoAddresses?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {