@ronin/compiler 0.5.0 → 0.5.1

package/README.md

@@ -59,7 +59,7 @@ const schemas: Array<Schema> = [{
 
 const statements: Array<Statements> = compileQueries(queries, schemas);
 // [{
-//   statement: 'SELECT * FROM "accounts" ORDER BY "ronin.createdAt" DESC LIMIT 101',
+//   statement: 'SELECT * FROM "accounts"',
 //   params: [],
 //   returning: true,
 // }]

package/dist/index.js

@@ -317,7 +317,7 @@ var getTableForSchema = (schema) => {
   return convertToSnakeCase(schema.pluralSlug);
 };
 var composeMetaSchemaSlug = (suffix) => convertToCamelCase(`ronin_${suffix}`);
-var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.pluralSlug}_${field.slug}`);
+var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.slug}_${field.slug}`);
 var getFieldSelector = (field, fieldPath, rootTable) => {
   const symbol = rootTable?.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD) ? `${rootTable.replace(RONIN_SCHEMA_SYMBOLS.FIELD, "").slice(0, -1)}.` : "";
   const tablePrefix = symbol || (rootTable ? `"${rootTable}".` : "");
@@ -352,6 +352,53 @@ var getFieldFromSchema = (schema, fieldPath, instructionName, rootTable) => {
   const fieldSelector = getFieldSelector(schemaField, fieldPath, rootTable);
   return { field: schemaField, fieldSelector };
 };
+var slugToName = (slug) => {
+  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
+  return title(name);
+};
+var VOWELS = ["a", "e", "i", "o", "u"];
+var pluralize = (word) => {
+  const lastLetter = word.slice(-1).toLowerCase();
+  const secondLastLetter = word.slice(-2, -1).toLowerCase();
+  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (lastLetter === "s" || word.slice(-2).toLowerCase() === "ch" || word.slice(-2).toLowerCase() === "sh" || word.slice(-2).toLowerCase() === "ex") {
+    return `${word}es`;
+  }
+  return `${word}s`;
+};
+var schemaSettings = [
+  ["pluralSlug", "slug", pluralize],
+  ["name", "slug", slugToName],
+  ["pluralName", "pluralSlug", slugToName],
+  ["idPrefix", "slug", (slug) => slug.slice(0, 3)]
+];
+var addDefaultSchemaFields = (schema, isNew) => {
+  const copiedSchema = { ...schema };
+  for (const [setting, base, generator] of schemaSettings) {
+    if (copiedSchema[setting] || !copiedSchema[base]) continue;
+    copiedSchema[setting] = generator(copiedSchema[base]);
+  }
+  const newFields = copiedSchema.fields || [];
+  if (isNew || newFields.length > 0) {
+    if (!copiedSchema.identifiers) copiedSchema.identifiers = {};
+    if (!copiedSchema.identifiers.name) {
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
+      );
+      copiedSchema.identifiers.name = suitableField?.slug || "id";
+    }
+    if (!copiedSchema.identifiers.slug) {
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(field.slug)
+      );
+      copiedSchema.identifiers.slug = suitableField?.slug || "id";
+    }
+    copiedSchema.fields = [...SYSTEM_FIELDS, ...newFields];
+  }
+  return copiedSchema;
+};
 var SYSTEM_FIELDS = [
   {
     name: "ID",
@@ -392,16 +439,12 @@ var SYSTEM_FIELDS = [
 ];
 var SYSTEM_SCHEMAS = [
   {
-    name: "Schema",
-    pluralName: "Schemas",
     slug: "schema",
-    pluralSlug: "schemas",
     identifiers: {
       name: "name",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "name", type: "string" },
       { slug: "pluralName", type: "string" },
       { slug: "slug", type: "string" },
@@ -412,20 +455,18 @@ var SYSTEM_SCHEMAS = [
       { slug: "identifiers.slug", type: "string" },
       { slug: "fields", type: "json" },
       { slug: "indexes", type: "json" },
-      { slug: "triggers", type: "json" }
+      { slug: "triggers", type: "json" },
+      { slug: "including", type: "json" },
+      { slug: "for", type: "json" }
     ]
   },
   {
-    name: "Field",
-    pluralName: "Fields",
     slug: "field",
-    pluralSlug: "fields",
     identifiers: {
       name: "name",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "name", type: "string" },
       { slug: "slug", type: "string", required: true },
       { slug: "type", type: "string", required: true },
@@ -448,16 +489,12 @@ var SYSTEM_SCHEMAS = [
     ]
   },
   {
-    name: "Index",
-    pluralName: "Indexes",
     slug: "index",
-    pluralSlug: "indexes",
     identifiers: {
       name: "slug",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "slug", type: "string", required: true },
       {
         slug: "schema",
@@ -470,16 +507,12 @@ var SYSTEM_SCHEMAS = [
     ]
   },
   {
-    name: "Trigger",
-    pluralName: "Triggers",
     slug: "trigger",
-    pluralSlug: "triggers",
     identifiers: {
       name: "slug",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "slug", type: "string", required: true },
       { slug: "schema", type: "reference", target: { slug: "schema" }, required: true },
       { slug: "cause", type: "string", required: true },
@@ -487,85 +520,89 @@ var SYSTEM_SCHEMAS = [
       { slug: "effects", type: "json", required: true }
     ]
   }
-];
+].map((schema) => addDefaultSchemaFields(schema, true));
 var SYSTEM_SCHEMA_SLUGS = SYSTEM_SCHEMAS.flatMap(({ slug, pluralSlug }) => [
   slug,
   pluralSlug
 ]);
-var prepareSchema = (schema) => {
-  const copiedSchema = { ...schema };
-  if (!copiedSchema.pluralSlug) copiedSchema.pluralSlug = pluralize(copiedSchema.slug);
-  if (!copiedSchema.name) copiedSchema.name = slugToName(copiedSchema.slug);
-  if (!copiedSchema.pluralName)
-    copiedSchema.pluralName = slugToName(copiedSchema.pluralSlug);
-  if (!copiedSchema.idPrefix) copiedSchema.idPrefix = copiedSchema.slug.slice(0, 3);
-  if (!copiedSchema.identifiers) copiedSchema.identifiers = {};
-  if (!copiedSchema.identifiers.name) copiedSchema.identifiers.name = "id";
-  if (!copiedSchema.identifiers.slug) copiedSchema.identifiers.slug = "id";
-  return copiedSchema;
-};
 var addSystemSchemas = (schemas) => {
-  const list = [...SYSTEM_SCHEMAS, ...schemas].map(prepareSchema);
-  for (const schema of list) {
-    const defaultIncluding = {};
+  const associativeSchemas = schemas.flatMap((schema) => {
+    const addedSchemas = [];
     for (const field of schema.fields || []) {
       if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-        const relatedSchema = getSchemaBySlug(list, field.target.slug);
+        const relatedSchema = getSchemaBySlug(schemas, field.target.slug);
         let fieldSlug = relatedSchema.slug;
         if (field.kind === "many") {
           fieldSlug = composeAssociationSchemaSlug(schema, field);
-          list.push({
+          addedSchemas.push({
             pluralSlug: fieldSlug,
             slug: fieldSlug,
-            identifiers: {
-              name: "id",
-              slug: "id"
-            },
             fields: [
               {
                 slug: "source",
                 type: "reference",
-                target: schema
+                target: { slug: schema.slug }
               },
               {
                 slug: "target",
                 type: "reference",
-                target: relatedSchema
+                target: { slug: relatedSchema.slug }
               }
             ]
           });
         }
-        defaultIncluding[field.slug] = {
-          get: {
-            [fieldSlug]: {
-              with: {
-                // Compare the `id` field of the related schema to the reference field on
-                // the root schema (`field.slug`).
-                id: `${RONIN_SCHEMA_SYMBOLS.FIELD}${field.slug}`
-              }
+      }
+    }
+    return addedSchemas;
+  });
+  return [...SYSTEM_SCHEMAS, ...associativeSchemas, ...schemas];
+};
+var addDefaultSchemaShortcuts = (list, schema) => {
+  const defaultIncluding = {};
+  for (const field of schema.fields || []) {
+    if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
+      const relatedSchema = getSchemaBySlug(list, field.target.slug);
+      let fieldSlug = relatedSchema.slug;
+      if (field.kind === "many") {
+        fieldSlug = composeAssociationSchemaSlug(schema, field);
+      }
+      defaultIncluding[field.slug] = {
+        get: {
+          [fieldSlug]: {
+            with: {
+              // Compare the `id` field of the related schema to the reference field on
+              // the root schema (`field.slug`).
+              id: `${RONIN_SCHEMA_SYMBOLS.FIELD}${field.slug}`
             }
           }
-        };
-        const relatedSchemaToModify = getSchemaBySlug(list, field.target.slug);
-        if (!relatedSchemaToModify) throw new Error("Missing related schema");
-        relatedSchemaToModify.including = {
-          [schema.pluralSlug]: {
-            get: {
-              [schema.pluralSlug]: {
-                with: {
-                  [field.slug]: `${RONIN_SCHEMA_SYMBOLS.FIELD}id`
-                }
-              }
-            }
-          },
-          ...relatedSchemaToModify.including
-        };
-      }
+        }
+      };
     }
-    schema.fields = [...SYSTEM_FIELDS, ...schema.fields || []];
+  }
+  const childSchemas = list.map((subSchema) => {
+    const field = subSchema.fields?.find((field2) => {
+      return field2.type === "reference" && field2.target.slug === schema.slug;
+    });
+    if (!field) return null;
+    return { schema: subSchema, field };
+  }).filter((match) => match !== null);
+  for (const childMatch of childSchemas) {
+    const { schema: childSchema, field: childField } = childMatch;
+    const pluralSlug = childSchema.pluralSlug;
+    defaultIncluding[pluralSlug] = {
+      get: {
+        [pluralSlug]: {
+          with: {
+            [childField.slug]: `${RONIN_SCHEMA_SYMBOLS.FIELD}id`
+          }
+        }
+      }
+    };
+  }
+  if (Object.keys(defaultIncluding).length > 0) {
     schema.including = { ...defaultIncluding, ...schema.including };
   }
-  return list;
+  return schema;
 };
 var mappedInstructions = {
   create: "to",
@@ -713,28 +750,38 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
     dependencyStatements.push({ statement: statement2, params });
     return queryInstructions;
   }
-  let statement = `${tableAction} TABLE "${tableName}"`;
+  const statement = `${tableAction} TABLE "${tableName}"`;
   if (kind === "schemas") {
-    const providedFields = instructionList?.fields || [];
-    const fields = [...SYSTEM_FIELDS, ...providedFields];
     if (queryType === "create" || queryType === "set") {
-      queryInstructions.to = prepareSchema(queryInstructions.to);
+      const schemaWithFields = addDefaultSchemaFields(
+        queryInstructions.to,
+        queryType === "create"
+      );
+      const schemaWithShortcuts = addDefaultSchemaShortcuts(schemas, schemaWithFields);
+      queryInstructions.to = schemaWithShortcuts;
     }
     if (queryType === "create") {
+      const { fields } = queryInstructions.to;
       const columns = fields.map(getFieldStatement).filter(Boolean);
-      statement += ` (${columns.join(", ")})`;
+      dependencyStatements.push({
+        statement: `${statement} (${columns.join(", ")})`,
+        params: []
+      });
       schemas.push(queryInstructions.to);
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.pluralSlug;
       if (newSlug) {
         const newTable = convertToSnakeCase(newSlug);
-        statement += ` RENAME TO "${newTable}"`;
+        dependencyStatements.push({
+          statement: `${statement} RENAME TO "${newTable}"`,
+          params: []
+        });
       }
       Object.assign(targetSchema, queryInstructions.to);
     } else if (queryType === "drop") {
       schemas.splice(schemas.indexOf(targetSchema), 1);
+      dependencyStatements.push({ statement, params: [] });
     }
-    dependencyStatements.push({ statement, params: [] });
     return queryInstructions;
   }
   if (kind === "fields") {
@@ -746,35 +793,27 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
           fields: ["type"]
         });
       }
-      statement += ` ADD COLUMN ${getFieldStatement(instructionList)}`;
+      dependencyStatements.push({
+        statement: `${statement} ADD COLUMN ${getFieldStatement(instructionList)}`,
+        params: []
+      });
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.slug;
       if (newSlug) {
-        statement += ` RENAME COLUMN "${slug}" TO "${newSlug}"`;
+        dependencyStatements.push({
+          statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
+          params: []
+        });
       }
     } else if (queryType === "drop") {
-      statement += ` DROP COLUMN "${slug}"`;
+      dependencyStatements.push({
+        statement: `${statement} DROP COLUMN "${slug}"`,
+        params: []
+      });
     }
-    dependencyStatements.push({ statement, params: [] });
   }
   return queryInstructions;
 };
-var slugToName = (slug) => {
-  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
-  return title(name);
-};
-var VOWELS = ["a", "e", "i", "o", "u"];
-var pluralize = (word) => {
-  const lastLetter = word.slice(-1).toLowerCase();
-  const secondLastLetter = word.slice(-2, -1).toLowerCase();
-  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  if (lastLetter === "s" || word.slice(-2).toLowerCase() === "ch" || word.slice(-2).toLowerCase() === "sh" || word.slice(-2).toLowerCase() === "ex") {
-    return `${word}es`;
-  }
-  return `${word}s`;
-};
 
 // src/instructions/before-after.ts
 var CURSOR_SEPARATOR = ",";
@@ -783,15 +822,22 @@ var handleBeforeOrAfter = (schema, statementParams, instructions, rootTable) =>
   if (!(instructions.before || instructions.after)) {
     throw new RoninError({
       message: "The `before` or `after` instruction must not be empty.",
-      code: "MISSING_INSTRUCTION",
-      queries: null
+      code: "MISSING_INSTRUCTION"
     });
   }
   if (instructions.before && instructions.after) {
     throw new RoninError({
       message: "The `before` and `after` instructions cannot co-exist. Choose one.",
-      code: "MUTUALLY_EXCLUSIVE_INSTRUCTIONS",
-      queries: null
+      code: "MUTUALLY_EXCLUSIVE_INSTRUCTIONS"
+    });
+  }
+  if (!instructions.limitedTo) {
+    let message = "When providing a pagination cursor in the `before` or `after`";
+    message += " instruction, a `limitedTo` instruction must be provided as well, to";
+    message += " define the page size.";
+    throw new RoninError({
+      message,
+      code: "MISSING_INSTRUCTION"
     });
   }
   const { ascending = [], descending = [] } = instructions.orderedBy || {};
@@ -951,9 +997,10 @@ var handleIncluding = (schemas, statementParams, schema, instruction, rootTable)
 
 // src/instructions/limited-to.ts
 var handleLimitedTo = (single, instruction) => {
-  const pageSize = instruction || 100;
-  const finalPageSize = pageSize + 1;
-  return `LIMIT ${single ? "1" : finalPageSize} `;
+  let amount;
+  if (instruction) amount = instruction + 1;
+  if (single) amount = 1;
+  return `LIMIT ${amount} `;
 };
 
 // src/instructions/ordered-by.ts
@@ -1217,7 +1264,7 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
     );
     if (forStatement.length > 0) conditions.push(forStatement);
   }
-  if ((queryType === "get" || queryType === "count") && !single) {
+  if ((queryType === "get" || queryType === "count") && !single && instructions?.limitedTo) {
     instructions = instructions || {};
     instructions.orderedBy = instructions.orderedBy || {};
     instructions.orderedBy.ascending = instructions.orderedBy.ascending || [];
@@ -1244,7 +1291,8 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
         before: instructions.before,
         after: instructions.after,
         with: instructions.with,
-        orderedBy: instructions.orderedBy
+        orderedBy: instructions.orderedBy,
+        limitedTo: instructions.limitedTo
       },
       isJoining ? table : void 0
     );
@@ -1265,7 +1313,7 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
     );
     statement += `${orderedByStatement} `;
   }
-  if (queryType === "get" && !isJoiningMultipleRows) {
+  if (queryType === "get" && !isJoiningMultipleRows && (single || instructions?.limitedTo)) {
     statement += handleLimitedTo(single, instructions?.limitedTo);
   }
   if (["create", "set", "drop"].includes(queryType) && returning) {
@@ -1284,13 +1332,18 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
 
 // src/index.ts
 var compileQueries = (queries, schemas, options) => {
-  const schemaList = addSystemSchemas(schemas);
+  const schemaList = addSystemSchemas(schemas).map((schema) => {
+    return addDefaultSchemaFields(schema, true);
+  });
+  const schemaListWithShortcuts = schemaList.map((schema) => {
+    return addDefaultSchemaShortcuts(schemaList, schema);
+  });
   const dependencyStatements = [];
   const mainStatements = [];
   for (const query of queries) {
     const result = compileQueryInput(
       query,
-      schemaList,
+      schemaListWithShortcuts,
       options?.inlineValues ? null : []
     );
     dependencyStatements.push(...result.dependencies);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {