@constructive-sdk/cli 0.21.5 → 0.21.7

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;

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

@@ -27,14 +27,18 @@ export class SiteModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Site', 'sites', args.select, {
             where: args?.where,
-        }, 'SiteFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteFilter', 'SiteOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Site',
-            fieldName: 'sites',
+            fieldName: 'site',
             document,
             variables,
+            transform: (data) => ({
+                site: data.sites?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteMetadatumModel {
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
         siteMetadata: ConnectionResult<InferSelectResult<SiteMetadatumWithRelations, S>>;
     }>;
-    findFirst<S extends SiteMetadatumSelect>(args: FindFirstArgs<S, SiteMetadatumFilter> & {
+    findFirst<S extends SiteMetadatumSelect>(args: FindFirstArgs<S, SiteMetadatumFilter, SiteMetadatumOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
-        siteMetadata: {
-            nodes: InferSelectResult<SiteMetadatumWithRelations, S>[];
-        };
+        siteMetadatum: InferSelectResult<SiteMetadatumWithRelations, S> | null;
     }>;
     findOne<S extends SiteMetadatumSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SiteMetadatumModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteMetadatum', 'siteMetadata', args.select, {
             where: args?.where,
-        }, 'SiteMetadatumFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteMetadatumFilter', 'SiteMetadatumOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteMetadatum',
-            fieldName: 'siteMetadata',
+            fieldName: 'siteMetadatum',
             document,
             variables,
+            transform: (data) => ({
+                siteMetadatum: data.siteMetadata?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteModuleModel {
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
         siteModules: ConnectionResult<InferSelectResult<SiteModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SiteModuleSelect>(args: FindFirstArgs<S, SiteModuleFilter> & {
+    findFirst<S extends SiteModuleSelect>(args: FindFirstArgs<S, SiteModuleFilter, SiteModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
-        siteModules: {
-            nodes: InferSelectResult<SiteModuleWithRelations, S>[];
-        };
+        siteModule: InferSelectResult<SiteModuleWithRelations, S> | null;
     }>;
     findOne<S extends SiteModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SiteModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteModule', 'siteModules', args.select, {
             where: args?.where,
-        }, 'SiteModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteModuleFilter', 'SiteModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteModule',
-            fieldName: 'siteModules',
+            fieldName: 'siteModule',
             document,
             variables,
+            transform: (data) => ({
+                siteModule: data.siteModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SiteThemeModel {
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
         siteThemes: ConnectionResult<InferSelectResult<SiteThemeWithRelations, S>>;
     }>;
-    findFirst<S extends SiteThemeSelect>(args: FindFirstArgs<S, SiteThemeFilter> & {
+    findFirst<S extends SiteThemeSelect>(args: FindFirstArgs<S, SiteThemeFilter, SiteThemeOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
-        siteThemes: {
-            nodes: InferSelectResult<SiteThemeWithRelations, S>[];
-        };
+        siteTheme: InferSelectResult<SiteThemeWithRelations, S> | null;
     }>;
     findOne<S extends SiteThemeSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class SiteThemeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteTheme', 'siteThemes', args.select, {
             where: args?.where,
-        }, 'SiteThemeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteThemeFilter', 'SiteThemeOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteTheme',
-            fieldName: 'siteThemes',
+            fieldName: 'siteTheme',
             document,
             variables,
+            transform: (data) => ({
+                siteTheme: data.siteThemes?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class SpatialRelationModel {
     } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
         spatialRelations: ConnectionResult<InferSelectResult<SpatialRelationWithRelations, S>>;
     }>;
-    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter> & {
+    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter, SpatialRelationOrderBy> & {
         select: S;
     } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
-        spatialRelations: {
-            nodes: InferSelectResult<SpatialRelationWithRelations, S>[];
-        };
+        spatialRelation: InferSelectResult<SpatialRelationWithRelations, S> | null;
     }>;
     findOne<S extends SpatialRelationSelect>(args: {
         id: string;