@constructive-io/react 0.19.6 → 0.19.7

package/public/orm/models/agentTask.js

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

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

@@ -15,12 +15,10 @@ export declare class AgentThreadModel {
     } & StrictSelect<S, AgentThreadSelect>): QueryBuilder<{
         agentThreads: ConnectionResult<InferSelectResult<AgentThreadWithRelations, S>>;
     }>;
-    findFirst<S extends AgentThreadSelect>(args: FindFirstArgs<S, AgentThreadFilter> & {
+    findFirst<S extends AgentThreadSelect>(args: FindFirstArgs<S, AgentThreadFilter, AgentThreadOrderBy> & {
         select: S;
     } & StrictSelect<S, AgentThreadSelect>): QueryBuilder<{
-        agentThreads: {
-            nodes: InferSelectResult<AgentThreadWithRelations, S>[];
-        };
+        agentThread: InferSelectResult<AgentThreadWithRelations, S> | null;
     }>;
     findOne<S extends AgentThreadSelect>(args: {
         id: string;

package/public/orm/models/agentThread.js

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

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

@@ -15,12 +15,10 @@ export declare class ApiModel {
     } & StrictSelect<S, ApiSelect>): QueryBuilder<{
         apis: ConnectionResult<InferSelectResult<ApiWithRelations, S>>;
     }>;
-    findFirst<S extends ApiSelect>(args: FindFirstArgs<S, ApiFilter> & {
+    findFirst<S extends ApiSelect>(args: FindFirstArgs<S, ApiFilter, ApiOrderBy> & {
         select: S;
     } & StrictSelect<S, ApiSelect>): QueryBuilder<{
-        apis: {
-            nodes: InferSelectResult<ApiWithRelations, S>[];
-        };
+        api: InferSelectResult<ApiWithRelations, S> | null;
     }>;
     findOne<S extends ApiSelect>(args: {
         id: string;

package/public/orm/models/api.js

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

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

@@ -15,12 +15,10 @@ export declare class ApiModuleModel {
     } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
         apiModules: ConnectionResult<InferSelectResult<ApiModuleWithRelations, S>>;
     }>;
-    findFirst<S extends ApiModuleSelect>(args: FindFirstArgs<S, ApiModuleFilter> & {
+    findFirst<S extends ApiModuleSelect>(args: FindFirstArgs<S, ApiModuleFilter, ApiModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
-        apiModules: {
-            nodes: InferSelectResult<ApiModuleWithRelations, S>[];
-        };
+        apiModule: InferSelectResult<ApiModuleWithRelations, S> | null;
     }>;
     findOne<S extends ApiModuleSelect>(args: {
         id: string;

package/public/orm/models/apiModule.js

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

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

@@ -15,12 +15,10 @@ export declare class ApiSchemaModel {
     } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
         apiSchemas: ConnectionResult<InferSelectResult<ApiSchemaWithRelations, S>>;
     }>;
-    findFirst<S extends ApiSchemaSelect>(args: FindFirstArgs<S, ApiSchemaFilter> & {
+    findFirst<S extends ApiSchemaSelect>(args: FindFirstArgs<S, ApiSchemaFilter, ApiSchemaOrderBy> & {
         select: S;
     } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
-        apiSchemas: {
-            nodes: InferSelectResult<ApiSchemaWithRelations, S>[];
-        };
+        apiSchema: InferSelectResult<ApiSchemaWithRelations, S> | null;
     }>;
     findOne<S extends ApiSchemaSelect>(args: {
         id: string;

package/public/orm/models/apiSchema.js

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

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

@@ -15,12 +15,10 @@ export declare class ApiSettingModel {
     } & StrictSelect<S, ApiSettingSelect>): QueryBuilder<{
         apiSettings: ConnectionResult<InferSelectResult<ApiSettingWithRelations, S>>;
     }>;
-    findFirst<S extends ApiSettingSelect>(args: FindFirstArgs<S, ApiSettingFilter> & {
+    findFirst<S extends ApiSettingSelect>(args: FindFirstArgs<S, ApiSettingFilter, ApiSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, ApiSettingSelect>): QueryBuilder<{
-        apiSettings: {
-            nodes: InferSelectResult<ApiSettingWithRelations, S>[];
-        };
+        apiSetting: InferSelectResult<ApiSettingWithRelations, S> | null;
     }>;
     findOne<S extends ApiSettingSelect>(args: {
         id: string;

package/public/orm/models/apiSetting.js

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

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

@@ -15,12 +15,10 @@ export declare class AppModel {
     } & StrictSelect<S, AppSelect>): QueryBuilder<{
         apps: ConnectionResult<InferSelectResult<AppWithRelations, S>>;
     }>;
-    findFirst<S extends AppSelect>(args: FindFirstArgs<S, AppFilter> & {
+    findFirst<S extends AppSelect>(args: FindFirstArgs<S, AppFilter, AppOrderBy> & {
         select: S;
     } & StrictSelect<S, AppSelect>): QueryBuilder<{
-        apps: {
-            nodes: InferSelectResult<AppWithRelations, S>[];
-        };
+        app: InferSelectResult<AppWithRelations, S> | null;
     }>;
     findOne<S extends AppSelect>(args: {
         id: string;

package/public/orm/models/app.js

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

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

@@ -15,12 +15,10 @@ export declare class AppAchievementModel {
     } & StrictSelect<S, AppAchievementSelect>): QueryBuilder<{
         appAchievements: ConnectionResult<InferSelectResult<AppAchievementWithRelations, S>>;
     }>;
-    findFirst<S extends AppAchievementSelect>(args: FindFirstArgs<S, AppAchievementFilter> & {
+    findFirst<S extends AppAchievementSelect>(args: FindFirstArgs<S, AppAchievementFilter, AppAchievementOrderBy> & {
         select: S;
     } & StrictSelect<S, AppAchievementSelect>): QueryBuilder<{
-        appAchievements: {
-            nodes: InferSelectResult<AppAchievementWithRelations, S>[];
-        };
+        appAchievement: InferSelectResult<AppAchievementWithRelations, S> | null;
     }>;
     findOne<S extends AppAchievementSelect>(args: {
         id: string;

package/public/orm/models/appAchievement.js

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

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

@@ -15,12 +15,10 @@ export declare class AppAdminGrantModel {
     } & StrictSelect<S, AppAdminGrantSelect>): QueryBuilder<{
         appAdminGrants: ConnectionResult<InferSelectResult<AppAdminGrantWithRelations, S>>;
     }>;
-    findFirst<S extends AppAdminGrantSelect>(args: FindFirstArgs<S, AppAdminGrantFilter> & {
+    findFirst<S extends AppAdminGrantSelect>(args: FindFirstArgs<S, AppAdminGrantFilter, AppAdminGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, AppAdminGrantSelect>): QueryBuilder<{
-        appAdminGrants: {
-            nodes: InferSelectResult<AppAdminGrantWithRelations, S>[];
-        };
+        appAdminGrant: InferSelectResult<AppAdminGrantWithRelations, S> | null;
     }>;
     findOne<S extends AppAdminGrantSelect>(args: {
         id: string;

package/public/orm/models/appAdminGrant.js

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

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

@@ -15,12 +15,10 @@ export declare class AppClaimedInviteModel {
     } & StrictSelect<S, AppClaimedInviteSelect>): QueryBuilder<{
         appClaimedInvites: ConnectionResult<InferSelectResult<AppClaimedInviteWithRelations, S>>;
     }>;
-    findFirst<S extends AppClaimedInviteSelect>(args: FindFirstArgs<S, AppClaimedInviteFilter> & {
+    findFirst<S extends AppClaimedInviteSelect>(args: FindFirstArgs<S, AppClaimedInviteFilter, AppClaimedInviteOrderBy> & {
         select: S;
     } & StrictSelect<S, AppClaimedInviteSelect>): QueryBuilder<{
-        appClaimedInvites: {
-            nodes: InferSelectResult<AppClaimedInviteWithRelations, S>[];
-        };
+        appClaimedInvite: InferSelectResult<AppClaimedInviteWithRelations, S> | null;
     }>;
     findOne<S extends AppClaimedInviteSelect>(args: {
         id: string;

package/public/orm/models/appClaimedInvite.js

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

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

@@ -15,12 +15,10 @@ export declare class AppGrantModel {
     } & StrictSelect<S, AppGrantSelect>): QueryBuilder<{
         appGrants: ConnectionResult<InferSelectResult<AppGrantWithRelations, S>>;
     }>;
-    findFirst<S extends AppGrantSelect>(args: FindFirstArgs<S, AppGrantFilter> & {
+    findFirst<S extends AppGrantSelect>(args: FindFirstArgs<S, AppGrantFilter, AppGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, AppGrantSelect>): QueryBuilder<{
-        appGrants: {
-            nodes: InferSelectResult<AppGrantWithRelations, S>[];
-        };
+        appGrant: InferSelectResult<AppGrantWithRelations, S> | null;
     }>;
     findOne<S extends AppGrantSelect>(args: {
         id: string;

package/public/orm/models/appGrant.js

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

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

@@ -15,12 +15,10 @@ export declare class AppInviteModel {
     } & StrictSelect<S, AppInviteSelect>): QueryBuilder<{
         appInvites: ConnectionResult<InferSelectResult<AppInviteWithRelations, S>>;
     }>;
-    findFirst<S extends AppInviteSelect>(args: FindFirstArgs<S, AppInviteFilter> & {
+    findFirst<S extends AppInviteSelect>(args: FindFirstArgs<S, AppInviteFilter, AppInviteOrderBy> & {
         select: S;
     } & StrictSelect<S, AppInviteSelect>): QueryBuilder<{
-        appInvites: {
-            nodes: InferSelectResult<AppInviteWithRelations, S>[];
-        };
+        appInvite: InferSelectResult<AppInviteWithRelations, S> | null;
     }>;
     findOne<S extends AppInviteSelect>(args: {
         id: string;

package/public/orm/models/appInvite.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLevelModel {
     } & StrictSelect<S, AppLevelSelect>): QueryBuilder<{
         appLevels: ConnectionResult<InferSelectResult<AppLevelWithRelations, S>>;
     }>;
-    findFirst<S extends AppLevelSelect>(args: FindFirstArgs<S, AppLevelFilter> & {
+    findFirst<S extends AppLevelSelect>(args: FindFirstArgs<S, AppLevelFilter, AppLevelOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLevelSelect>): QueryBuilder<{
-        appLevels: {
-            nodes: InferSelectResult<AppLevelWithRelations, S>[];
-        };
+        appLevel: InferSelectResult<AppLevelWithRelations, S> | null;
     }>;
     findOne<S extends AppLevelSelect>(args: {
         id: string;

package/public/orm/models/appLevel.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLevelRequirementModel {
     } & StrictSelect<S, AppLevelRequirementSelect>): QueryBuilder<{
         appLevelRequirements: ConnectionResult<InferSelectResult<AppLevelRequirementWithRelations, S>>;
     }>;
-    findFirst<S extends AppLevelRequirementSelect>(args: FindFirstArgs<S, AppLevelRequirementFilter> & {
+    findFirst<S extends AppLevelRequirementSelect>(args: FindFirstArgs<S, AppLevelRequirementFilter, AppLevelRequirementOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLevelRequirementSelect>): QueryBuilder<{
-        appLevelRequirements: {
-            nodes: InferSelectResult<AppLevelRequirementWithRelations, S>[];
-        };
+        appLevelRequirement: InferSelectResult<AppLevelRequirementWithRelations, S> | null;
     }>;
     findOne<S extends AppLevelRequirementSelect>(args: {
         id: string;

package/public/orm/models/appLevelRequirement.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitModel {
     } & StrictSelect<S, AppLimitSelect>): QueryBuilder<{
         appLimits: ConnectionResult<InferSelectResult<AppLimitWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitSelect>(args: FindFirstArgs<S, AppLimitFilter> & {
+    findFirst<S extends AppLimitSelect>(args: FindFirstArgs<S, AppLimitFilter, AppLimitOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitSelect>): QueryBuilder<{
-        appLimits: {
-            nodes: InferSelectResult<AppLimitWithRelations, S>[];
-        };
+        appLimit: InferSelectResult<AppLimitWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitSelect>(args: {
         id: string;

package/public/orm/models/appLimit.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitCapModel {
     } & StrictSelect<S, AppLimitCapSelect>): QueryBuilder<{
         appLimitCaps: ConnectionResult<InferSelectResult<AppLimitCapWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitCapSelect>(args: FindFirstArgs<S, AppLimitCapFilter> & {
+    findFirst<S extends AppLimitCapSelect>(args: FindFirstArgs<S, AppLimitCapFilter, AppLimitCapOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitCapSelect>): QueryBuilder<{
-        appLimitCaps: {
-            nodes: InferSelectResult<AppLimitCapWithRelations, S>[];
-        };
+        appLimitCap: InferSelectResult<AppLimitCapWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitCapSelect>(args: {
         id: string;

package/public/orm/models/appLimitCap.js

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

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

@@ -15,12 +15,10 @@ export declare class AppLimitCapsDefaultModel {
     } & StrictSelect<S, AppLimitCapsDefaultSelect>): QueryBuilder<{
         appLimitCapsDefaults: ConnectionResult<InferSelectResult<AppLimitCapsDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends AppLimitCapsDefaultSelect>(args: FindFirstArgs<S, AppLimitCapsDefaultFilter> & {
+    findFirst<S extends AppLimitCapsDefaultSelect>(args: FindFirstArgs<S, AppLimitCapsDefaultFilter, AppLimitCapsDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, AppLimitCapsDefaultSelect>): QueryBuilder<{
-        appLimitCapsDefaults: {
-            nodes: InferSelectResult<AppLimitCapsDefaultWithRelations, S>[];
-        };
+        appLimitCapsDefault: InferSelectResult<AppLimitCapsDefaultWithRelations, S> | null;
     }>;
     findOne<S extends AppLimitCapsDefaultSelect>(args: {
         id: string;

package/public/orm/models/appLimitCapsDefault.js

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