Skip to content

Commit 494b6fc

Browse files
glennmichael123glennmichael123
committed
chore: wip
1 parent 1bdd919 commit 494b6fc

File tree

17 files changed

+1069
-0
lines changed

17 files changed

+1069
-0
lines changed

‎storage/framework/core/orm/src/generate.ts

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1108,6 +1108,67 @@ export async function generateModelString(
11081108
return instance
11091109
}
11101110
1111+
static whereDoesntHave(
1112+
relation: string,
1113+
callback: (query: SubqueryBuilder) => void
1114+
): ${modelName}Model {
1115+
const instance = new ${modelName}Model(null)
1116+
const subqueryBuilder = new SubqueryBuilder()
1117+
1118+
callback(subqueryBuilder)
1119+
const conditions = subqueryBuilder.getConditions()
1120+
1121+
instance.selectFromQuery = instance.selectFromQuery
1122+
.where(({ exists, selectFrom, not }: any) => {
1123+
let subquery = selectFrom(relation)
1124+
.select('1')
1125+
.whereRef(\`\${relation}.${formattedModelName}_id\`, '=', '${tableName}.id')
1126+
1127+
conditions.forEach((condition) => {
1128+
switch (condition.method) {
1129+
case 'where':
1130+
if (condition.type === 'and') {
1131+
subquery = subquery.where(condition.column, condition.operator!, condition.value)
1132+
} else {
1133+
subquery = subquery.orWhere(condition.column, condition.operator!, condition.value)
1134+
}
1135+
break
1136+
1137+
case 'whereIn':
1138+
if (condition.operator === 'not') {
1139+
subquery = subquery.whereNotIn(condition.column, condition.values!)
1140+
} else {
1141+
subquery = subquery.whereIn(condition.column, condition.values!)
1142+
}
1143+
1144+
break
1145+
1146+
case 'whereNull':
1147+
subquery = subquery.whereNull(condition.column)
1148+
break
1149+
1150+
case 'whereNotNull':
1151+
subquery = subquery.whereNotNull(condition.column)
1152+
break
1153+
1154+
case 'whereBetween':
1155+
subquery = subquery.whereBetween(condition.column, condition.values!)
1156+
break
1157+
1158+
case 'whereExists': {
1159+
const nestedBuilder = new SubqueryBuilder()
1160+
condition.callback!(nestedBuilder)
1161+
break
1162+
}
1163+
}
1164+
})
1165+
1166+
return not(exists(subquery))
1167+
})
1168+
1169+
return instance
1170+
}
1171+
11111172
async paginate(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<${modelName}Response> {
11121173
return ${modelName}Model.paginate(options)
11131174
}

‎storage/framework/orm/src/models/AccessToken.ts

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -443,6 +443,69 @@ export class AccessTokenModel {
443443
return instance
444444
}
445445

446+
static whereDoesntHave(
447+
relation: string,
448+
callback: (query: SubqueryBuilder) => void,
449+
): AccessTokenModel {
450+
const instance = new AccessTokenModel(null)
451+
const subqueryBuilder = new SubqueryBuilder()
452+
453+
callback(subqueryBuilder)
454+
const conditions = subqueryBuilder.getConditions()
455+
456+
instance.selectFromQuery = instance.selectFromQuery
457+
.where(({ exists, selectFrom, not }: any) => {
458+
let subquery = selectFrom(relation)
459+
.select('1')
460+
.whereRef(`${relation}.accesstoken_id`, '=', 'personal_access_tokens.id')
461+
462+
conditions.forEach((condition) => {
463+
switch (condition.method) {
464+
case 'where':
465+
if (condition.type === 'and') {
466+
subquery = subquery.where(condition.column, condition.operator!, condition.value)
467+
}
468+
else {
469+
subquery = subquery.orWhere(condition.column, condition.operator!, condition.value)
470+
}
471+
break
472+
473+
case 'whereIn':
474+
if (condition.operator === 'not') {
475+
subquery = subquery.whereNotIn(condition.column, condition.values!)
476+
}
477+
else {
478+
subquery = subquery.whereIn(condition.column, condition.values!)
479+
}
480+
481+
break
482+
483+
case 'whereNull':
484+
subquery = subquery.whereNull(condition.column)
485+
break
486+
487+
case 'whereNotNull':
488+
subquery = subquery.whereNotNull(condition.column)
489+
break
490+
491+
case 'whereBetween':
492+
subquery = subquery.whereBetween(condition.column, condition.values!)
493+
break
494+
495+
case 'whereExists': {
496+
const nestedBuilder = new SubqueryBuilder()
497+
condition.callback!(nestedBuilder)
498+
break
499+
}
500+
}
501+
})
502+
503+
return not(exists(subquery))
504+
})
505+
506+
return instance
507+
}
508+
446509
async paginate(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<AccessTokenResponse> {
447510
return AccessTokenModel.paginate(options)
448511
}

‎storage/framework/orm/src/models/Deployment.ts

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -456,6 +456,69 @@ export class DeploymentModel {
456456
return instance
457457
}
458458

459+
static whereDoesntHave(
460+
relation: string,
461+
callback: (query: SubqueryBuilder) => void,
462+
): DeploymentModel {
463+
const instance = new DeploymentModel(null)
464+
const subqueryBuilder = new SubqueryBuilder()
465+
466+
callback(subqueryBuilder)
467+
const conditions = subqueryBuilder.getConditions()
468+
469+
instance.selectFromQuery = instance.selectFromQuery
470+
.where(({ exists, selectFrom, not }: any) => {
471+
let subquery = selectFrom(relation)
472+
.select('1')
473+
.whereRef(`${relation}.deployment_id`, '=', 'deployments.id')
474+
475+
conditions.forEach((condition) => {
476+
switch (condition.method) {
477+
case 'where':
478+
if (condition.type === 'and') {
479+
subquery = subquery.where(condition.column, condition.operator!, condition.value)
480+
}
481+
else {
482+
subquery = subquery.orWhere(condition.column, condition.operator!, condition.value)
483+
}
484+
break
485+
486+
case 'whereIn':
487+
if (condition.operator === 'not') {
488+
subquery = subquery.whereNotIn(condition.column, condition.values!)
489+
}
490+
else {
491+
subquery = subquery.whereIn(condition.column, condition.values!)
492+
}
493+
494+
break
495+
496+
case 'whereNull':
497+
subquery = subquery.whereNull(condition.column)
498+
break
499+
500+
case 'whereNotNull':
501+
subquery = subquery.whereNotNull(condition.column)
502+
break
503+
504+
case 'whereBetween':
505+
subquery = subquery.whereBetween(condition.column, condition.values!)
506+
break
507+
508+
case 'whereExists': {
509+
const nestedBuilder = new SubqueryBuilder()
510+
condition.callback!(nestedBuilder)
511+
break
512+
}
513+
}
514+
})
515+
516+
return not(exists(subquery))
517+
})
518+
519+
return instance
520+
}
521+
459522
async paginate(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<DeploymentResponse> {
460523
return DeploymentModel.paginate(options)
461524
}

‎storage/framework/orm/src/models/Error.ts

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -433,6 +433,69 @@ export class ErrorModel {
433433
return instance
434434
}
435435

436+
static whereDoesntHave(
437+
relation: string,
438+
callback: (query: SubqueryBuilder) => void,
439+
): ErrorModel {
440+
const instance = new ErrorModel(null)
441+
const subqueryBuilder = new SubqueryBuilder()
442+
443+
callback(subqueryBuilder)
444+
const conditions = subqueryBuilder.getConditions()
445+
446+
instance.selectFromQuery = instance.selectFromQuery
447+
.where(({ exists, selectFrom, not }: any) => {
448+
let subquery = selectFrom(relation)
449+
.select('1')
450+
.whereRef(`${relation}.error_id`, '=', 'errors.id')
451+
452+
conditions.forEach((condition) => {
453+
switch (condition.method) {
454+
case 'where':
455+
if (condition.type === 'and') {
456+
subquery = subquery.where(condition.column, condition.operator!, condition.value)
457+
}
458+
else {
459+
subquery = subquery.orWhere(condition.column, condition.operator!, condition.value)
460+
}
461+
break
462+
463+
case 'whereIn':
464+
if (condition.operator === 'not') {
465+
subquery = subquery.whereNotIn(condition.column, condition.values!)
466+
}
467+
else {
468+
subquery = subquery.whereIn(condition.column, condition.values!)
469+
}
470+
471+
break
472+
473+
case 'whereNull':
474+
subquery = subquery.whereNull(condition.column)
475+
break
476+
477+
case 'whereNotNull':
478+
subquery = subquery.whereNotNull(condition.column)
479+
break
480+
481+
case 'whereBetween':
482+
subquery = subquery.whereBetween(condition.column, condition.values!)
483+
break
484+
485+
case 'whereExists': {
486+
const nestedBuilder = new SubqueryBuilder()
487+
condition.callback!(nestedBuilder)
488+
break
489+
}
490+
}
491+
})
492+
493+
return not(exists(subquery))
494+
})
495+
496+
return instance
497+
}
498+
436499
async paginate(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<ErrorResponse> {
437500
return ErrorModel.paginate(options)
438501
}

‎storage/framework/orm/src/models/FailedJob.ts

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -433,6 +433,69 @@ export class FailedJobModel {
433433
return instance
434434
}
435435

436+
static whereDoesntHave(
437+
relation: string,
438+
callback: (query: SubqueryBuilder) => void,
439+
): FailedJobModel {
440+
const instance = new FailedJobModel(null)
441+
const subqueryBuilder = new SubqueryBuilder()
442+
443+
callback(subqueryBuilder)
444+
const conditions = subqueryBuilder.getConditions()
445+
446+
instance.selectFromQuery = instance.selectFromQuery
447+
.where(({ exists, selectFrom, not }: any) => {
448+
let subquery = selectFrom(relation)
449+
.select('1')
450+
.whereRef(`${relation}.failedjob_id`, '=', 'failed_jobs.id')
451+
452+
conditions.forEach((condition) => {
453+
switch (condition.method) {
454+
case 'where':
455+
if (condition.type === 'and') {
456+
subquery = subquery.where(condition.column, condition.operator!, condition.value)
457+
}
458+
else {
459+
subquery = subquery.orWhere(condition.column, condition.operator!, condition.value)
460+
}
461+
break
462+
463+
case 'whereIn':
464+
if (condition.operator === 'not') {
465+
subquery = subquery.whereNotIn(condition.column, condition.values!)
466+
}
467+
else {
468+
subquery = subquery.whereIn(condition.column, condition.values!)
469+
}
470+
471+
break
472+
473+
case 'whereNull':
474+
subquery = subquery.whereNull(condition.column)
475+
break
476+
477+
case 'whereNotNull':
478+
subquery = subquery.whereNotNull(condition.column)
479+
break
480+
481+
case 'whereBetween':
482+
subquery = subquery.whereBetween(condition.column, condition.values!)
483+
break
484+
485+
case 'whereExists': {
486+
const nestedBuilder = new SubqueryBuilder()
487+
condition.callback!(nestedBuilder)
488+
break
489+
}
490+
}
491+
})
492+
493+
return not(exists(subquery))
494+
})
495+
496+
return instance
497+
}
498+
436499
async paginate(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<FailedJobResponse> {
437500
return FailedJobModel.paginate(options)
438501
}

0 commit comments

Comments
 (0)