@constructive-io/react 0.19.5 → 0.19.7

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;

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

@@ -27,14 +27,18 @@ export class SchemaModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Schema', 'schemas', args.select, {
             where: args?.where,
-        }, 'SchemaFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SchemaFilter', 'SchemaOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Schema',
-            fieldName: 'schemas',
+            fieldName: 'schema',
             document,
             variables,
+            transform: (data) => ({
+                schema: data.schemas?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SchemaGrantModel {
     } & StrictSelect<S, SchemaGrantSelect>): QueryBuilder<{
         schemaGrants: ConnectionResult<InferSelectResult<SchemaGrantWithRelations, S>>;
     }>;
-    findFirst<S extends SchemaGrantSelect>(args: FindFirstArgs<S, SchemaGrantFilter> & {
+    findFirst<S extends SchemaGrantSelect>(args: FindFirstArgs<S, SchemaGrantFilter, SchemaGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, SchemaGrantSelect>): QueryBuilder<{
-        schemaGrants: {
-            nodes: InferSelectResult<SchemaGrantWithRelations, S>[];
-        };
+        schemaGrant: InferSelectResult<SchemaGrantWithRelations, S> | null;
     }>;
     findOne<S extends SchemaGrantSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SchemaGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SchemaGrant', 'schemaGrants', args.select, {
             where: args?.where,
-        }, 'SchemaGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SchemaGrantFilter', 'SchemaGrantOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SchemaGrant',
-            fieldName: 'schemaGrants',
+            fieldName: 'schemaGrant',
             document,
             variables,
+            transform: (data) => ({
+                schemaGrant: data.schemaGrants?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SecretsModuleModel {
     } & StrictSelect<S, SecretsModuleSelect>): QueryBuilder<{
         secretsModules: ConnectionResult<InferSelectResult<SecretsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SecretsModuleSelect>(args: FindFirstArgs<S, SecretsModuleFilter> & {
+    findFirst<S extends SecretsModuleSelect>(args: FindFirstArgs<S, SecretsModuleFilter, SecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SecretsModuleSelect>): QueryBuilder<{
-        secretsModules: {
-            nodes: InferSelectResult<SecretsModuleWithRelations, S>[];
-        };
+        secretsModule: InferSelectResult<SecretsModuleWithRelations, S> | null;
     }>;
     findOne<S extends SecretsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SecretsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SecretsModule', 'secretsModules', args.select, {
             where: args?.where,
-        }, 'SecretsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SecretsModuleFilter', 'SecretsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SecretsModule',
-            fieldName: 'secretsModules',
+            fieldName: 'secretsModule',
             document,
             variables,
+            transform: (data) => ({
+                secretsModule: data.secretsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SecureTableProvisionModel {
     } & StrictSelect<S, SecureTableProvisionSelect>): QueryBuilder<{
         secureTableProvisions: ConnectionResult<InferSelectResult<SecureTableProvisionWithRelations, S>>;
     }>;
-    findFirst<S extends SecureTableProvisionSelect>(args: FindFirstArgs<S, SecureTableProvisionFilter> & {
+    findFirst<S extends SecureTableProvisionSelect>(args: FindFirstArgs<S, SecureTableProvisionFilter, SecureTableProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, SecureTableProvisionSelect>): QueryBuilder<{
-        secureTableProvisions: {
-            nodes: InferSelectResult<SecureTableProvisionWithRelations, S>[];
-        };
+        secureTableProvision: InferSelectResult<SecureTableProvisionWithRelations, S> | null;
     }>;
     findOne<S extends SecureTableProvisionSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SecureTableProvisionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SecureTableProvision', 'secureTableProvisions', args.select, {
             where: args?.where,
-        }, 'SecureTableProvisionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SecureTableProvisionFilter', 'SecureTableProvisionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SecureTableProvision',
-            fieldName: 'secureTableProvisions',
+            fieldName: 'secureTableProvision',
             document,
             variables,
+            transform: (data) => ({
+                secureTableProvision: data.secureTableProvisions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SessionSecretsModuleModel {
     } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
         sessionSecretsModules: ConnectionResult<InferSelectResult<SessionSecretsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SessionSecretsModuleSelect>(args: FindFirstArgs<S, SessionSecretsModuleFilter> & {
+    findFirst<S extends SessionSecretsModuleSelect>(args: FindFirstArgs<S, SessionSecretsModuleFilter, SessionSecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
-        sessionSecretsModules: {
-            nodes: InferSelectResult<SessionSecretsModuleWithRelations, S>[];
-        };
+        sessionSecretsModule: InferSelectResult<SessionSecretsModuleWithRelations, S> | null;
     }>;
     findOne<S extends SessionSecretsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SessionSecretsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SessionSecretsModule', 'sessionSecretsModules', args.select, {
             where: args?.where,
-        }, 'SessionSecretsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SessionSecretsModuleFilter', 'SessionSecretsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SessionSecretsModule',
-            fieldName: 'sessionSecretsModules',
+            fieldName: 'sessionSecretsModule',
             document,
             variables,
+            transform: (data) => ({
+                sessionSecretsModule: data.sessionSecretsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SessionsModuleModel {
     } & StrictSelect<S, SessionsModuleSelect>): QueryBuilder<{
         sessionsModules: ConnectionResult<InferSelectResult<SessionsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SessionsModuleSelect>(args: FindFirstArgs<S, SessionsModuleFilter> & {
+    findFirst<S extends SessionsModuleSelect>(args: FindFirstArgs<S, SessionsModuleFilter, SessionsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SessionsModuleSelect>): QueryBuilder<{
-        sessionsModules: {
-            nodes: InferSelectResult<SessionsModuleWithRelations, S>[];
-        };
+        sessionsModule: InferSelectResult<SessionsModuleWithRelations, S> | null;
     }>;
     findOne<S extends SessionsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SessionsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SessionsModule', 'sessionsModules', args.select, {
             where: args?.where,
-        }, 'SessionsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SessionsModuleFilter', 'SessionsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SessionsModule',
-            fieldName: 'sessionsModules',
+            fieldName: 'sessionsModule',
             document,
             variables,
+            transform: (data) => ({
+                sessionsModule: data.sessionsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteModel {
     } & StrictSelect<S, SiteSelect>): QueryBuilder<{
         sites: ConnectionResult<InferSelectResult<SiteWithRelations, S>>;
     }>;
-    findFirst<S extends SiteSelect>(args: FindFirstArgs<S, SiteFilter> & {
+    findFirst<S extends SiteSelect>(args: FindFirstArgs<S, SiteFilter, SiteOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteSelect>): QueryBuilder<{
-        sites: {
-            nodes: InferSelectResult<SiteWithRelations, S>[];
-        };
+        site: InferSelectResult<SiteWithRelations, S> | null;
     }>;
     findOne<S extends SiteSelect>(args: {
         id: string;