@constructive-sdk/cli 0.21.6 → 0.21.8

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

@@ -27,14 +27,18 @@ export class AppAdminGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppAdminGrant', 'appAdminGrants', args.select, {
             where: args?.where,
-        }, 'AppAdminGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppAdminGrantFilter', 'AppAdminGrantOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appClaimedInvite.js

@@ -27,14 +27,18 @@ export class AppClaimedInviteModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppClaimedInvite', 'appClaimedInvites', args.select, {
             where: args?.where,
-        }, 'AppClaimedInviteFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppClaimedInviteFilter', 'AppClaimedInviteOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appGrant.js

@@ -27,14 +27,18 @@ export class AppGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppGrant', 'appGrants', args.select, {
             where: args?.where,
-        }, 'AppGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppGrantFilter', 'AppGrantOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appInvite.js

@@ -27,14 +27,18 @@ export class AppInviteModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppInvite', 'appInvites', args.select, {
             where: args?.where,
-        }, 'AppInviteFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppInviteFilter', 'AppInviteOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLevel.js

@@ -27,14 +27,18 @@ export class AppLevelModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLevel', 'appLevels', args.select, {
             where: args?.where,
-        }, 'AppLevelFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLevelFilter', 'AppLevelOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLevelRequirement.js

@@ -27,14 +27,18 @@ export class AppLevelRequirementModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLevelRequirement', 'appLevelRequirements', args.select, {
             where: args?.where,
-        }, 'AppLevelRequirementFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLevelRequirementFilter', 'AppLevelRequirementOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimit.js

@@ -27,14 +27,18 @@ export class AppLimitModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimit', 'appLimits', args.select, {
             where: args?.where,
-        }, 'AppLimitFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitFilter', 'AppLimitOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitCap.js

@@ -27,14 +27,18 @@ export class AppLimitCapModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitCap', 'appLimitCaps', args.select, {
             where: args?.where,
-        }, 'AppLimitCapFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitCapFilter', 'AppLimitCapOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitCapsDefault.js

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

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

@@ -27,14 +27,18 @@ export class AppLimitCreditModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitCredit', 'appLimitCredits', args.select, {
             where: args?.where,
-        }, 'AppLimitCreditFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitCreditFilter', 'AppLimitCreditOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitCreditCode.js

@@ -27,14 +27,18 @@ export class AppLimitCreditCodeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitCreditCode', 'appLimitCreditCodes', args.select, {
             where: args?.where,
-        }, 'AppLimitCreditCodeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitCreditCodeFilter', 'AppLimitCreditCodeOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitCreditCodeItem.js

@@ -27,14 +27,18 @@ export class AppLimitCreditCodeItemModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitCreditCodeItem', 'appLimitCreditCodeItems', args.select, {
             where: args?.where,
-        }, 'AppLimitCreditCodeItemFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitCreditCodeItemFilter', 'AppLimitCreditCodeItemOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitCreditRedemption.js

@@ -27,14 +27,18 @@ export class AppLimitCreditRedemptionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitCreditRedemption', 'appLimitCreditRedemptions', args.select, {
             where: args?.where,
-        }, 'AppLimitCreditRedemptionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitCreditRedemptionFilter', 'AppLimitCreditRedemptionOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitDefault.js

@@ -27,14 +27,18 @@ export class AppLimitDefaultModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitDefault', 'appLimitDefaults', args.select, {
             where: args?.where,
-        }, 'AppLimitDefaultFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitDefaultFilter', 'AppLimitDefaultOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appLimitEvent.js

@@ -27,14 +27,18 @@ export class AppLimitEventModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('AppLimitEvent', 'appLimitEvents', args.select, {
             where: args?.where,
-        }, 'AppLimitEventFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppLimitEventFilter', 'AppLimitEventOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/appMembership.js

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