@constructive-io/sdk 0.21.6 → 0.21.8

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

@@ -15,12 +15,10 @@ export declare class PartitionModel {
     } & StrictSelect<S, PartitionSelect>): QueryBuilder<{
         partitions: ConnectionResult<InferSelectResult<PartitionWithRelations, S>>;
     }>;
-    findFirst<S extends PartitionSelect>(args: FindFirstArgs<S, PartitionFilter> & {
+    findFirst<S extends PartitionSelect>(args: FindFirstArgs<S, PartitionFilter, PartitionOrderBy> & {
         select: S;
     } & StrictSelect<S, PartitionSelect>): QueryBuilder<{
-        partitions: {
-            nodes: InferSelectResult<PartitionWithRelations, S>[];
-        };
+        partition: InferSelectResult<PartitionWithRelations, S> | null;
     }>;
     findOne<S extends PartitionSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PartitionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Partition', 'partitions', args.select, {
             where: args?.where,
-        }, 'PartitionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PartitionFilter', 'PartitionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Partition',
-            fieldName: 'partitions',
+            fieldName: 'partition',
             document,
             variables,
+            transform: (data) => ({
+                partition: data.partitions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PermissionsModuleModel {
     } & StrictSelect<S, PermissionsModuleSelect>): QueryBuilder<{
         permissionsModules: ConnectionResult<InferSelectResult<PermissionsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends PermissionsModuleSelect>(args: FindFirstArgs<S, PermissionsModuleFilter> & {
+    findFirst<S extends PermissionsModuleSelect>(args: FindFirstArgs<S, PermissionsModuleFilter, PermissionsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PermissionsModuleSelect>): QueryBuilder<{
-        permissionsModules: {
-            nodes: InferSelectResult<PermissionsModuleWithRelations, S>[];
-        };
+        permissionsModule: InferSelectResult<PermissionsModuleWithRelations, S> | null;
     }>;
     findOne<S extends PermissionsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PermissionsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PermissionsModule', 'permissionsModules', args.select, {
             where: args?.where,
-        }, 'PermissionsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PermissionsModuleFilter', 'PermissionsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PermissionsModule',
-            fieldName: 'permissionsModules',
+            fieldName: 'permissionsModule',
             document,
             variables,
+            transform: (data) => ({
+                permissionsModule: data.permissionsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PhoneNumberModel {
     } & StrictSelect<S, PhoneNumberSelect>): QueryBuilder<{
         phoneNumbers: ConnectionResult<InferSelectResult<PhoneNumberWithRelations, S>>;
     }>;
-    findFirst<S extends PhoneNumberSelect>(args: FindFirstArgs<S, PhoneNumberFilter> & {
+    findFirst<S extends PhoneNumberSelect>(args: FindFirstArgs<S, PhoneNumberFilter, PhoneNumberOrderBy> & {
         select: S;
     } & StrictSelect<S, PhoneNumberSelect>): QueryBuilder<{
-        phoneNumbers: {
-            nodes: InferSelectResult<PhoneNumberWithRelations, S>[];
-        };
+        phoneNumber: InferSelectResult<PhoneNumberWithRelations, S> | null;
     }>;
     findOne<S extends PhoneNumberSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PhoneNumberModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PhoneNumber', 'phoneNumbers', args.select, {
             where: args?.where,
-        }, 'PhoneNumberFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PhoneNumberFilter', 'PhoneNumberOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PhoneNumber',
-            fieldName: 'phoneNumbers',
+            fieldName: 'phoneNumber',
             document,
             variables,
+            transform: (data) => ({
+                phoneNumber: data.phoneNumbers?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PhoneNumbersModuleModel {
     } & StrictSelect<S, PhoneNumbersModuleSelect>): QueryBuilder<{
         phoneNumbersModules: ConnectionResult<InferSelectResult<PhoneNumbersModuleWithRelations, S>>;
     }>;
-    findFirst<S extends PhoneNumbersModuleSelect>(args: FindFirstArgs<S, PhoneNumbersModuleFilter> & {
+    findFirst<S extends PhoneNumbersModuleSelect>(args: FindFirstArgs<S, PhoneNumbersModuleFilter, PhoneNumbersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PhoneNumbersModuleSelect>): QueryBuilder<{
-        phoneNumbersModules: {
-            nodes: InferSelectResult<PhoneNumbersModuleWithRelations, S>[];
-        };
+        phoneNumbersModule: InferSelectResult<PhoneNumbersModuleWithRelations, S> | null;
     }>;
     findOne<S extends PhoneNumbersModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PhoneNumbersModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PhoneNumbersModule', 'phoneNumbersModules', args.select, {
             where: args?.where,
-        }, 'PhoneNumbersModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PhoneNumbersModuleFilter', 'PhoneNumbersModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PhoneNumbersModule',
-            fieldName: 'phoneNumbersModules',
+            fieldName: 'phoneNumbersModule',
             document,
             variables,
+            transform: (data) => ({
+                phoneNumbersModule: data.phoneNumbersModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PlansModuleModel {
     } & StrictSelect<S, PlansModuleSelect>): QueryBuilder<{
         plansModules: ConnectionResult<InferSelectResult<PlansModuleWithRelations, S>>;
     }>;
-    findFirst<S extends PlansModuleSelect>(args: FindFirstArgs<S, PlansModuleFilter> & {
+    findFirst<S extends PlansModuleSelect>(args: FindFirstArgs<S, PlansModuleFilter, PlansModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PlansModuleSelect>): QueryBuilder<{
-        plansModules: {
-            nodes: InferSelectResult<PlansModuleWithRelations, S>[];
-        };
+        plansModule: InferSelectResult<PlansModuleWithRelations, S> | null;
     }>;
     findOne<S extends PlansModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PlansModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PlansModule', 'plansModules', args.select, {
             where: args?.where,
-        }, 'PlansModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PlansModuleFilter', 'PlansModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PlansModule',
-            fieldName: 'plansModules',
+            fieldName: 'plansModule',
             document,
             variables,
+            transform: (data) => ({
+                plansModule: data.plansModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PolicyModel {
     } & StrictSelect<S, PolicySelect>): QueryBuilder<{
         policies: ConnectionResult<InferSelectResult<PolicyWithRelations, S>>;
     }>;
-    findFirst<S extends PolicySelect>(args: FindFirstArgs<S, PolicyFilter> & {
+    findFirst<S extends PolicySelect>(args: FindFirstArgs<S, PolicyFilter, PolicyOrderBy> & {
         select: S;
     } & StrictSelect<S, PolicySelect>): QueryBuilder<{
-        policies: {
-            nodes: InferSelectResult<PolicyWithRelations, S>[];
-        };
+        policy: InferSelectResult<PolicyWithRelations, S> | null;
     }>;
     findOne<S extends PolicySelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PolicyModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Policy', 'policies', args.select, {
             where: args?.where,
-        }, 'PolicyFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PolicyFilter', 'PolicyOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Policy',
-            fieldName: 'policies',
+            fieldName: 'policy',
             document,
             variables,
+            transform: (data) => ({
+                policy: data.policies?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PrimaryKeyConstraintModel {
     } & StrictSelect<S, PrimaryKeyConstraintSelect>): QueryBuilder<{
         primaryKeyConstraints: ConnectionResult<InferSelectResult<PrimaryKeyConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends PrimaryKeyConstraintSelect>(args: FindFirstArgs<S, PrimaryKeyConstraintFilter> & {
+    findFirst<S extends PrimaryKeyConstraintSelect>(args: FindFirstArgs<S, PrimaryKeyConstraintFilter, PrimaryKeyConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, PrimaryKeyConstraintSelect>): QueryBuilder<{
-        primaryKeyConstraints: {
-            nodes: InferSelectResult<PrimaryKeyConstraintWithRelations, S>[];
-        };
+        primaryKeyConstraint: InferSelectResult<PrimaryKeyConstraintWithRelations, S> | null;
     }>;
     findOne<S extends PrimaryKeyConstraintSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PrimaryKeyConstraintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PrimaryKeyConstraint', 'primaryKeyConstraints', args.select, {
             where: args?.where,
-        }, 'PrimaryKeyConstraintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PrimaryKeyConstraintFilter', 'PrimaryKeyConstraintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PrimaryKeyConstraint',
-            fieldName: 'primaryKeyConstraints',
+            fieldName: 'primaryKeyConstraint',
             document,
             variables,
+            transform: (data) => ({
+                primaryKeyConstraint: data.primaryKeyConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class ProfilesModuleModel {
     } & StrictSelect<S, ProfilesModuleSelect>): QueryBuilder<{
         profilesModules: ConnectionResult<InferSelectResult<ProfilesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends ProfilesModuleSelect>(args: FindFirstArgs<S, ProfilesModuleFilter> & {
+    findFirst<S extends ProfilesModuleSelect>(args: FindFirstArgs<S, ProfilesModuleFilter, ProfilesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ProfilesModuleSelect>): QueryBuilder<{
-        profilesModules: {
-            nodes: InferSelectResult<ProfilesModuleWithRelations, S>[];
-        };
+        profilesModule: InferSelectResult<ProfilesModuleWithRelations, S> | null;
     }>;
     findOne<S extends ProfilesModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class ProfilesModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('ProfilesModule', 'profilesModules', args.select, {
             where: args?.where,
-        }, 'ProfilesModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ProfilesModuleFilter', 'ProfilesModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ProfilesModule',
-            fieldName: 'profilesModules',
+            fieldName: 'profilesModule',
             document,
             variables,
+            transform: (data) => ({
+                profilesModule: data.profilesModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PubkeySettingModel {
     } & StrictSelect<S, PubkeySettingSelect>): QueryBuilder<{
         pubkeySettings: ConnectionResult<InferSelectResult<PubkeySettingWithRelations, S>>;
     }>;
-    findFirst<S extends PubkeySettingSelect>(args: FindFirstArgs<S, PubkeySettingFilter> & {
+    findFirst<S extends PubkeySettingSelect>(args: FindFirstArgs<S, PubkeySettingFilter, PubkeySettingOrderBy> & {
         select: S;
     } & StrictSelect<S, PubkeySettingSelect>): QueryBuilder<{
-        pubkeySettings: {
-            nodes: InferSelectResult<PubkeySettingWithRelations, S>[];
-        };
+        pubkeySetting: InferSelectResult<PubkeySettingWithRelations, S> | null;
     }>;
     findOne<S extends PubkeySettingSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PubkeySettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PubkeySetting', 'pubkeySettings', args.select, {
             where: args?.where,
-        }, 'PubkeySettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PubkeySettingFilter', 'PubkeySettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PubkeySetting',
-            fieldName: 'pubkeySettings',
+            fieldName: 'pubkeySetting',
             document,
             variables,
+            transform: (data) => ({
+                pubkeySetting: data.pubkeySettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RateLimitsModuleModel {
     } & StrictSelect<S, RateLimitsModuleSelect>): QueryBuilder<{
         rateLimitsModules: ConnectionResult<InferSelectResult<RateLimitsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends RateLimitsModuleSelect>(args: FindFirstArgs<S, RateLimitsModuleFilter> & {
+    findFirst<S extends RateLimitsModuleSelect>(args: FindFirstArgs<S, RateLimitsModuleFilter, RateLimitsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, RateLimitsModuleSelect>): QueryBuilder<{
-        rateLimitsModules: {
-            nodes: InferSelectResult<RateLimitsModuleWithRelations, S>[];
-        };
+        rateLimitsModule: InferSelectResult<RateLimitsModuleWithRelations, S> | null;
     }>;
     findOne<S extends RateLimitsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class RateLimitsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('RateLimitsModule', 'rateLimitsModules', args.select, {
             where: args?.where,
-        }, 'RateLimitsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RateLimitsModuleFilter', 'RateLimitsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'RateLimitsModule',
-            fieldName: 'rateLimitsModules',
+            fieldName: 'rateLimitsModule',
             document,
             variables,
+            transform: (data) => ({
+                rateLimitsModule: data.rateLimitsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RealtimeModuleModel {
     } & StrictSelect<S, RealtimeModuleSelect>): QueryBuilder<{
         realtimeModules: ConnectionResult<InferSelectResult<RealtimeModuleWithRelations, S>>;
     }>;
-    findFirst<S extends RealtimeModuleSelect>(args: FindFirstArgs<S, RealtimeModuleFilter> & {
+    findFirst<S extends RealtimeModuleSelect>(args: FindFirstArgs<S, RealtimeModuleFilter, RealtimeModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, RealtimeModuleSelect>): QueryBuilder<{
-        realtimeModules: {
-            nodes: InferSelectResult<RealtimeModuleWithRelations, S>[];
-        };
+        realtimeModule: InferSelectResult<RealtimeModuleWithRelations, S> | null;
     }>;
     findOne<S extends RealtimeModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class RealtimeModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('RealtimeModule', 'realtimeModules', args.select, {
             where: args?.where,
-        }, 'RealtimeModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RealtimeModuleFilter', 'RealtimeModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'RealtimeModule',
-            fieldName: 'realtimeModules',
+            fieldName: 'realtimeModule',
             document,
             variables,
+            transform: (data) => ({
+                realtimeModule: data.realtimeModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RefModel {
     } & StrictSelect<S, RefSelect>): QueryBuilder<{
         refs: ConnectionResult<InferSelectResult<RefWithRelations, S>>;
     }>;
-    findFirst<S extends RefSelect>(args: FindFirstArgs<S, RefFilter> & {
+    findFirst<S extends RefSelect>(args: FindFirstArgs<S, RefFilter, RefOrderBy> & {
         select: S;
     } & StrictSelect<S, RefSelect>): QueryBuilder<{
-        refs: {
-            nodes: InferSelectResult<RefWithRelations, S>[];
-        };
+        ref: InferSelectResult<RefWithRelations, S> | null;
     }>;
     findOne<S extends RefSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class RefModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Ref', 'refs', args.select, {
             where: args?.where,
-        }, 'RefFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RefFilter', 'RefOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Ref',
-            fieldName: 'refs',
+            fieldName: 'ref',
             document,
             variables,
+            transform: (data) => ({
+                ref: data.refs?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RelationProvisionModel {
     } & StrictSelect<S, RelationProvisionSelect>): QueryBuilder<{
         relationProvisions: ConnectionResult<InferSelectResult<RelationProvisionWithRelations, S>>;
     }>;
-    findFirst<S extends RelationProvisionSelect>(args: FindFirstArgs<S, RelationProvisionFilter> & {
+    findFirst<S extends RelationProvisionSelect>(args: FindFirstArgs<S, RelationProvisionFilter, RelationProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, RelationProvisionSelect>): QueryBuilder<{
-        relationProvisions: {
-            nodes: InferSelectResult<RelationProvisionWithRelations, S>[];
-        };
+        relationProvision: InferSelectResult<RelationProvisionWithRelations, S> | null;
     }>;
     findOne<S extends RelationProvisionSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class RelationProvisionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('RelationProvision', 'relationProvisions', args.select, {
             where: args?.where,
-        }, 'RelationProvisionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RelationProvisionFilter', 'RelationProvisionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'RelationProvision',
-            fieldName: 'relationProvisions',
+            fieldName: 'relationProvision',
             document,
             variables,
+            transform: (data) => ({
+                relationProvision: data.relationProvisions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RlsModuleModel {
     } & StrictSelect<S, RlsModuleSelect>): QueryBuilder<{
         rlsModules: ConnectionResult<InferSelectResult<RlsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends RlsModuleSelect>(args: FindFirstArgs<S, RlsModuleFilter> & {
+    findFirst<S extends RlsModuleSelect>(args: FindFirstArgs<S, RlsModuleFilter, RlsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, RlsModuleSelect>): QueryBuilder<{
-        rlsModules: {
-            nodes: InferSelectResult<RlsModuleWithRelations, S>[];
-        };
+        rlsModule: InferSelectResult<RlsModuleWithRelations, S> | null;
     }>;
     findOne<S extends RlsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class RlsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('RlsModule', 'rlsModules', args.select, {
             where: args?.where,
-        }, 'RlsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RlsModuleFilter', 'RlsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'RlsModule',
-            fieldName: 'rlsModules',
+            fieldName: 'rlsModule',
             document,
             variables,
+            transform: (data) => ({
+                rlsModule: data.rlsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RlsSettingModel {
     } & StrictSelect<S, RlsSettingSelect>): QueryBuilder<{
         rlsSettings: ConnectionResult<InferSelectResult<RlsSettingWithRelations, S>>;
     }>;
-    findFirst<S extends RlsSettingSelect>(args: FindFirstArgs<S, RlsSettingFilter> & {
+    findFirst<S extends RlsSettingSelect>(args: FindFirstArgs<S, RlsSettingFilter, RlsSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, RlsSettingSelect>): QueryBuilder<{
-        rlsSettings: {
-            nodes: InferSelectResult<RlsSettingWithRelations, S>[];
-        };
+        rlsSetting: InferSelectResult<RlsSettingWithRelations, S> | null;
     }>;
     findOne<S extends RlsSettingSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class RlsSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('RlsSetting', 'rlsSettings', args.select, {
             where: args?.where,
-        }, 'RlsSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RlsSettingFilter', 'RlsSettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'RlsSetting',
-            fieldName: 'rlsSettings',
+            fieldName: 'rlsSetting',
             document,
             variables,
+            transform: (data) => ({
+                rlsSetting: data.rlsSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class RoleTypeModel {
     } & StrictSelect<S, RoleTypeSelect>): QueryBuilder<{
         roleTypes: ConnectionResult<InferSelectResult<RoleTypeWithRelations, S>>;
     }>;
-    findFirst<S extends RoleTypeSelect>(args: FindFirstArgs<S, RoleTypeFilter> & {
+    findFirst<S extends RoleTypeSelect>(args: FindFirstArgs<S, RoleTypeFilter, RoleTypeOrderBy> & {
         select: S;
     } & StrictSelect<S, RoleTypeSelect>): QueryBuilder<{
-        roleTypes: {
-            nodes: InferSelectResult<RoleTypeWithRelations, S>[];
-        };
+        roleType: InferSelectResult<RoleTypeWithRelations, S> | null;
     }>;
     findOne<S extends RoleTypeSelect>(args: {
         id: number;

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

@@ -27,14 +27,18 @@ export class RoleTypeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('RoleType', 'roleTypes', args.select, {
             where: args?.where,
-        }, 'RoleTypeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'RoleTypeFilter', 'RoleTypeOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'RoleType',
-            fieldName: 'roleTypes',
+            fieldName: 'roleType',
             document,
             variables,
+            transform: (data) => ({
+                roleType: data.roleTypes?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SchemaModel {
     } & StrictSelect<S, SchemaSelect>): QueryBuilder<{
         schemas: ConnectionResult<InferSelectResult<SchemaWithRelations, S>>;
     }>;
-    findFirst<S extends SchemaSelect>(args: FindFirstArgs<S, SchemaFilter> & {
+    findFirst<S extends SchemaSelect>(args: FindFirstArgs<S, SchemaFilter, SchemaOrderBy> & {
         select: S;
     } & StrictSelect<S, SchemaSelect>): QueryBuilder<{
-        schemas: {
-            nodes: InferSelectResult<SchemaWithRelations, S>[];
-        };
+        schema: InferSelectResult<SchemaWithRelations, S> | null;
     }>;
     findOne<S extends SchemaSelect>(args: {
         id: string;